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

package com.framsticks.params;

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

import java.util.*;

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

    private static final Logger LOGGER = 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) {
        LOGGER.error("accesing unique list through index");
        assert false;
        return null;
        //LOGGER.error("accesing unique list through index");
        //return null;
        //return new ParamBuilder().setId(Integer.toString(i)).setName(elementAccess.getId()).setType("o " + elementAccess.getId()).build();
    }

    @Override
    public Param getParam(String id) {
        Integer i = Numbers.parse(id, Integer.class);
        if (i != null) {
            return getParam(i);
        }
        return new ParamBuilder().setId(id).setName(elementAccess.getId()).setType("o " + elementAccess.getId()).build();
    }

    @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) {
        LOGGER.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(Param 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) {
                LOGGER.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) {
        LOGGER.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)) {
                LOGGER.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;
        }
        LOGGER.error("missing both uid and id - failed to set");
        return 0;
    }

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

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

    @Override
    public void select(Object object) {
        map = (Map<String, Object>)object;
    }

    @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) {
            LOGGER.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;
    }
}