source: java/main/src/main/java/com/framsticks/params/UniqueListAccess.java @ 87

package com.framsticks.params;

import com.framsticks.util.lang.Casting;
import com.framsticks.util.lang.Numbers;
import org.apache.log4j.Logger;

import java.util.*;

/**
 * @author Piotr Sniegowski
 */
public class UniqueListAccess extends ListAccess {

        private static final Logger log = Logger.getLogger(UniqueListAccess.class.getName());

        Map<String, Object> map;

        final String uidName;

        public UniqueListAccess(AccessInterface elementAccess, String uidName) {
                super(elementAccess);
                this.uidName = uidName;
        }

        @Override
        public Map<String, Object> createAccessee() {
                return new HashMap<String, Object>();
        }

        @Override
        public Param getParam(int i) {
                log.error("accesing unique list through index");
                assert false;
                return null;
                //log.error("accesing unique list through index");
                //return null;
                //return Param.build().setId(Integer.toString(i)).setName(elementAccess.getId()).type("o " + elementAccess.getId()).build();
        }

        @Override
        public Param getParam(String id) {
                Integer i = Numbers.parse(id, Integer.class);
                if (i != null) {
                        return getParam(i);
                }
                //TODO list access here
                return Param.build().id(id).name(elementAccess.getId()).type("o " + elementAccess.getId()).finish();
        }

        @Override
        public String getId() {
                return "l " + elementAccess.getId() + " " + uidName;
        }

        @Override
        public int getParamCount() {
                return map.size();
        }

        @Override
        public <T> T get(int i, Class<T> type) {
                log.error("accesing unique list through index");
                assert false;
                return null;
                //Object[] values = map.values().toArray();
                //return Casting.tryCast(i < values.length ? values[i] : null, type);
        }

        @Override
        public <T> T get(String id, Class<T> type) {
                Integer i = Numbers.parse(id, Integer.class);
                if (i != null) {
                        return get(i, type);
                }
                return Casting.tryCast(type, map.containsKey(id) ? map.get(id) : null);
        }

        @Override
        public <T> T get(ValueParam param, Class<T> type) {
                return get(param.getId(), type);
        }

        public String getUidOf(Object value) {
                Object tmp = elementAccess.getSelected();
                elementAccess.select(value);
                String uid = elementAccess.get(uidName, String.class);
                elementAccess.select(tmp);
                if (uid == null) {
                        return null;
                }
                return uid;
        }

        protected int setByUid(Object object, String uid) {
                if (uid == null) {
                        uid = getUidOf(object);
                        if (uid == null) {
                                log.error("failed to set - missing uid");
                                return 0;
                        }
                }
                if (object == null) {
                        map.remove(uid);
                } else {
                        map.put(uid, object);
                }
                return 0;
        }

        @Override
        public <T> int set(int i, T value) {
                log.error("accesing unique list through index");
                //return setByUid(value, null);
                return 0;
        }

        @Override
        public <T> int set(String id, T value) {
                Integer i = Numbers.parse(id, Integer.class);
                if (i != null) {
                        return set(i, value);
                }
                if (value == null) {
                        return setByUid(null, id);
                }
                String uid = getUidOf(value);
                if (uid != null && id != null) {
                        if (!id.equals(uid)) {
                                log.error("uid mismatch with set key");
                                return 0;
                        }
                        setByUid(value, uid);
                        return 0;
                }
                if (uid != null) {
                        setByUid(value, uid);
                        return 0;
                }
                if (id != null) {
                        setByUid(value, id);
                        return 0;
                }
                log.error("missing both uid and id - failed to set");
                return 0;
        }

        @Override
        public <T> int set(ValueParam param, T value) {
                return set(param.getId(), value);
        }

        @Override
        public void clearValues() {
                map.clear();
        }

        @SuppressWarnings("unchecked")
        @Override
        public UniqueListAccess select(Object object) {
                assert (object instanceof Map);
                map = (Map<String, Object>) object;
                return this;
        }

        @Override
        public Object getSelected() {
                return map;
        }

        @Override
        public UniqueListAccess cloneAccess() {
                return new UniqueListAccess(elementAccess.cloneAccess(), uidName);
        }

        @Override
        public String computeIdentifierFor(Object selected) {
                String uid = getUidOf(selected);
                if (uid == null) {
                        log.error("missing uid field");
                        return null;
                }
                return uid;
        }

        @Override
        public Collection<Param> getParams() {
                List<Param> result = new LinkedList<Param>();
                if (map == null) {
                        return result;
                }
                for (String k : map.keySet()) {
                        result.add(getParam(k));
                }
                return result;
        }
}