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

package com.framsticks.params;

import com.framsticks.params.types.UniqueListParam;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.UnimplementedException;
import com.framsticks.util.FramsticksUnsupportedOperationException;
import com.framsticks.util.lang.Casting;
import com.framsticks.util.lang.Numbers;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import java.util.*;

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

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

        Map<String, Object> map;

        protected final String uidName;
        protected final Access uidAccess;

        public UniqueListAccess(Access elementAccess, String uidName) {
                super(elementAccess);
                this.uidName = uidName;
                uidAccess = elementAccess.cloneAccess();
        }

        public static Integer getUidNumber(String uid) {
                try {
                        return Integer.valueOf(uid.substring(1));
                } catch (NumberFormatException e) {
                        return null;
                }
        }

        /**
         * @return the uidName
         */
        public String getUidName() {
                return uidName;
        }

        public static class UidComparator implements Comparator<String> {

                protected Object description;


                /**
                 * @param description
                 */
                public UidComparator(Object description) {
                        this.description = description;
                }

                @Override
                public int compare(String a, String b) {
                        if (a.equals(b)) {
                                return 0;
                        }
                        int diff = a.length() - b.length();
                        if (diff != 0) {
                                return diff;
                        }
                        Integer au = getUidNumber(a);
                        Integer bu = getUidNumber(b);
                        if (au == null || bu == null) {
                                throw new FramsticksException().msg("comparator failure").arg("left", a).arg("right", b).arg("in", this);
                        }
                        return au - bu;
                }

                @Override
                public String toString() {
                        return "comparator " + description;
                }


        }

        public static <T> Map<String, T> createMap(Class<T> type, Object description) {
                return new TreeMap<String, T>(new UidComparator(description));
        }

        public static <M, T extends M> int getNumberInMap(Map<String, M> map, T object) {
                Iterator<Map.Entry<String, M>> iterator = map.entrySet().iterator();
                int number = 0;
                while (iterator.hasNext()) {
                        if (iterator.next().getValue() == object) {
                                return number;
                        }
                        ++number;
                }
                return -1;
        }

        @Override
        public Map<String, Object> createAccessee() {
                return createMap(Object.class, elementAccess);
        }

        @Override
        public CompositeParam getParam(int i) {
                if ((i < 0) ||  (i >= map.size())) {
                        return null;
                }
                Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
                while (i > 0 && iterator.hasNext()) {
                        iterator.next();
                        --i;
                }
                if (i > 0) {
                        return null;
                }
                if (!iterator.hasNext()) {
                        return null;
                }
                return paramBuilder.id(iterator.next().getKey()).finish(CompositeParam.class);
        }

        @Override
        public CompositeParam getParam(String id) {
                Integer i = Numbers.parse(id, Integer.class);
                if (i != null) {
                        return getParam(i);
                }
                Integer uidNumber = getUidNumber(id);
                if (uidNumber == null) {
                        return null;
                }
                if (!map.containsKey(id)) {
                        return null;
                }
                return paramBuilder.id(id).finish(CompositeParam.class);
        }


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

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

        @Override
        public <T> T get(int i, Class<T> type) {
                Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
                while (i > 0 && iterator.hasNext()) {
                        iterator.next();
                        --i;
                }
                if (i > 0) {
                        return null;
                }
                if (!iterator.hasNext()) {
                        return null;
                }
                return Casting.tryCast(type, iterator.next().getValue());
        }

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

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

        public String getUidOf(Object value) {
                return uidAccess.select(value).get(uidName, String.class);
        }

        public int setUidOf(Object value, String uid) {
                return uidAccess.select(value).set(uidName, uid);
        }

        protected int uidCounter = 1;

        public String generateNextUid() {
                return containedTypeName.substring(0, 1).toUpperCase() + Integer.toString(uidCounter++);
        }

        public String findNextFreeUid() {
                String uid;
                do {
                        uid = generateNextUid();
                } while (get(uid, Object.class) != null);
                return uid;
        }

        protected int setByUid(Object object, String uid) {
                if (uid == null) {
                        uid = getUidOf(object);
                        if (uid == null) {
                                uid = findNextFreeUid();
                                setUidOf(object, uid);
                        }
                }
                if (object == null) {
                        map.remove(uid);
                } else {
                        map.put(uid, object);
                }
                return 0;
        }

        @Override
        public <T> int set(int i, T value) {
                if (value != null) {
                        if (i != map.size()) {
                                throw new FramsticksUnsupportedOperationException().msg("setting element in unique list through index is available only for addition");
                        }
                        set(getUidOf(value), value);
                        return 0;
                }
                if (i >= map.size()) {
                        throw new FramsticksUnsupportedOperationException().msg("invalid index for removal");
                }
                Object current = get(i, Object.class);
                return setByUid(null, getUidOf(current));
        }

        @Override
        public <T> int set(String id, T value) {
                if (id == null) {
                        return setByUid(value, null);
                }
                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) {
                map = ParamsUtil.selectObjectForAccess(this, object, Map.class);
                return this;
        }

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

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

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

        @Override
        public Iterable<Param> getParams() {
                return new Iterable<Param>() {

                        @Override
                        public Iterator<Param> iterator() {
                                return new Iterator<Param>() {

                                        protected Iterator<Map.Entry<String, Object>> internal = map.entrySet().iterator();

                                        @Override
                                        public boolean hasNext() {
                                                return internal.hasNext();
                                        }

                                        @Override
                                        public Param next() {
                                                return paramBuilder.id(internal.next().getKey()).finish();
                                        }

                                        @Override
                                        public void remove() {
                                                throw new UnimplementedException().msg("remove element from list").arg("list", UniqueListAccess.this);

                                        }
                                };
                        }
                };
        }

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

        @Override
        public CompositeParam getCompositeParam(int number) {
                return getParam(number);
        }

        @Override
        public ParamBuilder buildParam(ParamBuilder builder) {
                return builder.name(containedTypeName + " list").type(UniqueListParam.class).containedTypeName(containedTypeName).uid(uidName);
        }

}