Application: gvSIG desktop » Library: org.gvsig.tools

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.lang.Cloneable;

public abstract class AbstractNamesTranslator implements NamesTranslator, Persistent {

    protected class SimpleMap implements Cloneable {

        public Map<String, String> map;

        public SimpleMap() {

            this.map = new HashMap<>();

        }

        public String get(String name) {

            return this.map.get(name.toLowerCase());

        }

        public void put(String name, String element) {

            this.map.put(name.toLowerCase(), element);

        }

        public Map<String, String> toMap() {

            return this.map;

        }

        @Override

        public SimpleMap clone() throws CloneNotSupportedException {

            SimpleMap clone = new SimpleMap();

            HashMap<String, String> newMap = new HashMap<>();

            newMap.putAll(map);

            clone.map = newMap;

            return clone;

        }

    protected class SimpleList implements Iterable<String>, Cloneable {

        public List<String> list;

        public SimpleList() {

            this.list = new ArrayList<>();

        }

        @Override

        public SimpleList clone() throws CloneNotSupportedException {

            SimpleList clone = new SimpleList();

            clone.toList().addAll(list);

            return clone;

        }

        public void add(String s) {

            list.add(s);

        }

        public boolean contains(String s) {

            for (String listElement : list) {

                if (StringUtils.equalsIgnoreCase(s, listElement)) {

                    return true;

                }

            }

            return false;

        }

        public int indexOf(String s) {

            for (int i = 0; i < list.size(); i++) {

                String element = list.get(i);

                if (StringUtils.equalsIgnoreCase(s, element)) {

                    return i;

                }

            }

            return -1;

        }

        public int size() {

            return list.size();

        }

        public String get(int index) {

            return list.get(index);

        }

        public void set(int index, String s) {

            list.set(index, s);

        }

        @Override

        public Iterator<String> iterator() {

            return list.iterator();

        }

        public List<String> toList() {

            return list;

        }

        public boolean hasUniqueValues() {

            HashSet<String> sourceNamesSet = new HashSet<String>();

            for (String sourceName : this.list) {

                sourceNamesSet.add(sourceName.toLowerCase());

            }

            return sourceNamesSet.size() == this.list.size();

        }

    protected SimpleList sourceNames;

    protected AbstractNamesTranslator() {

    }

    @Override

    public NamesTranslator clone() throws CloneNotSupportedException {

        AbstractNamesTranslator clone = (AbstractNamesTranslator) super.clone();

        clone.sourceNames = this.sourceNames.clone();

        return clone;

    }

    @Override

    public List<String> getSourceNames() {

        return this.sourceNames.toList();

    }

    @Override

    public void setSourceNames(Iterable<String> names) {

        this.sourceNames = new SimpleList();

        for (String name : names) {

            this.sourceNames.add(name);

        }

        this.build();

    }

    @Override

    public void setSourceNames(String[] names) {

        List<String> asList = Arrays.asList(names);

        this.setSourceNames(asList);

    }

    @Override

    public void setSourceNames(Iterable objs, Function<Object, String> name_getter) {

        this.sourceNames = new SimpleList();

        for (Object obj : objs) {

            String name = name_getter.apply(obj);

            this.sourceNames.add(name);

        }

        this.build();

    }

    @Override

    public String[] getTranslatedNamesAsArray() {

        List<String> l = this.getTranslatedNames();

        return l.toArray(new String[l.size()]);

    }

    @Override

    public String getSource(int index) {

        return this.sourceNames.get(index);

    }

    @Override

    public boolean isValid(String name) {

        return StringUtils.equalsIgnoreCase(name, this.getSuggestion(name));

    }

    protected abstract void build();

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("ClassName") == null) {

            DynStruct definition = manager.addDefinition(AbstractNamesTranslator.class,

                     "AbstractNamesTranslator", "AbstractNamesTranslator persistence definition", null, null);

            definition.addDynFieldList("sourceNames").setClassOfItems(String.class

            );

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("sourceNames", this.sourceNames.toList());

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        List sourceNamesState = state.getList("sourceNames");

        SimpleList sourceNamesList = new SimpleList();

        for (Object object : sourceNamesState) {

            sourceNamesList.add((String) object);

        }

        this.sourceNames = sourceNamesList;

    }