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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.namestranslator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.function.Function;

import org.apache.commons.lang3.StringUtils;

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;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractNamesTranslator implements NamesTranslator, Persistent {

    protected static 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;

        }

        public int size() {

            return this.map.size();

        }

        @Override

        public SimpleMap clone() throws CloneNotSupportedException {

            SimpleMap clone = (SimpleMap) super.clone();

            clone.map = new HashMap<>(this.map);

            return clone;

        }

    }

    protected static class SimpleList implements Iterable<String>, Cloneable {

        public List<String> list;

        public SimpleList() {

            this.list = new ArrayList<>();

        }

        @Override

        public SimpleList clone() throws CloneNotSupportedException {

            SimpleList clone = (SimpleList) super.clone();

            clone.list = new ArrayList<>(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 boolean isEmpty() {

          return this.list.isEmpty();

        }

        public List<String> toList() {

            return list;

        }

        public boolean hasUniqueValues() {

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

            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;

    }

}