Application: gvSIG desktop

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

    private List<ExportAttribute> exportAttributes;

    private AttributeNamesTranslator namesTranslator = null;

    private FeatureType sourceFeatureType;

    static final Logger LOGGER = LoggerFactory.getLogger(DefaultExportAttributes.class);

    private boolean active;

    public DefaultExportAttributes() {

        this.namesTranslator = new DummyAttributeNamesTranslator();

        this.active = false;

    }

    public void fillExportAttributes(FeatureType ftype) {

        ArrayList attrs = new ArrayList();

        if (ftype != null) {

            for (FeatureAttributeDescriptor fad : ftype) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad);

                String newName = this.getNamesTranslator().getNameSuggestion(fad.getName());

                exportAttribute.setNewName(newName);

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                exportAttribute.setExported(true);

                attrs.add(exportAttribute);

            }

        }

        this.setExportAttributes(attrs);

        this.fixAttributeNames();

    }

    @Override

    public void setNamesTranslator(AttributeNamesTranslator namesTranslator) {

        if (this.namesTranslator != namesTranslator) {

            this.namesTranslator = namesTranslator;

            if (this.sourceFeatureType != null) {

                this.fillExportAttributes(sourceFeatureType);

            }

        }

    }

    @Override

    public AttributeNamesTranslator getNamesTranslator() {

        return this.namesTranslator;

    }

    @Override

    public List<ExportAttribute> toList() {

        return this.exportAttributes;

    }

    @Override

    public boolean isEmpty() {

        return this.exportAttributes.isEmpty();

    }

    @Override

    public int size() {

        return this.exportAttributes.size();

    }

    @Override

    public Iterator<ExportAttribute> iterator() {

        return this.exportAttributes.iterator();

    }

    @Override

    public ExportAttribute get(int position) {

        return this.exportAttributes.get(position);

    }

    @Override

    public ExportAttribute getExportAttribute(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute;

            }

        }

        return null;

    }

    @Override

    public FeatureType getTargetFeatureType() {

        if (!this.isAttributeNamesValid()) {

            this.fixAttributeNames();

            LOGGER.warn("An extra fix attributes names in the feature type has been made");

        }

        EditableFeatureType targetFeatureType = this.getSourceFeatureType().getCopy().getEditable();

        for (FeatureAttributeDescriptor attrSource : this.getSourceFeatureType()) {

            FeatureAttributeDescriptor attr = targetFeatureType.getAttributeDescriptor(attrSource.getName());

            String name = attr.getName();

            ExportAttribute exportAttr = this.getExportAttribute(name);

            if (!exportAttr.isExported()) {

                targetFeatureType.remove(name);

                continue;

            }

            EditableFeatureAttributeDescriptor eAttr = targetFeatureType.getEditableAttributeDescriptor(name);

            if (this.getTargetName(name) == null ? name != null : !this.getTargetName(name).equals(name)) {

                eAttr.setName(this.getTargetName(name));

            }

            int type = attr.getDataType().getType();

            if (type != this.getTargetType(name)) {

                eAttr.setDataType(this.getTargetType(name));

                eAttr.setDefaultValue(null); // TODO: delete default value

            }

            int size = exportAttr.getSize();

            eAttr.setSize(size);

        }

        return targetFeatureType.getNotEditableCopy();

    }

    @Override

    public void setSourceFeatureType(FeatureType sourceFeatureType) {

        if (!sourceFeatureType.equals(this.sourceFeatureType)) {

            this.sourceFeatureType = sourceFeatureType;

            this.fillExportAttributes(this.sourceFeatureType);

        }

    }

    @Override

    public FeatureType getSourceFeatureType() {

        return this.sourceFeatureType;

    }

    @Override

    public String getTargetName(String name) {

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

            ExportAttribute exportAttribute = exportAttributes.get(i);

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                String newName = exportAttribute.getNewName();

                return newName;

            }

        }

        return null;

    }

    @Override

    public String getSourceName(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equalsIgnoreCase(exportAttribute.getNewName(), name)) {

                return exportAttribute.getName();

            }

        }

        return null;

    }

    @Override

    public int getTargetType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute.getNewDataType();

            }

        }

        return 0;

    }

    @Override

    public int getSourceType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getNewName(), name)) {

                return exportAttribute.getDataType();

            }

        }

        return 0;

    }

    @Override

    public boolean isAttributeNamesValid() {

        if (this.namesTranslator == null) {

            return true;

        }

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

            ExportAttribute attr = exportAttributes.get(i);

            if (!this.namesTranslator.isValidName(this, i, attr.getNewName())) {

                return false;

            }

        }

        return true;

    }

    @Override

    public void fixAttributeNames() {

        if (this.isAttributeNamesValid() == true) {

            return;

        }

        if (this.namesTranslator == null) {

            return;

        }

        int n = 0;

        while (!this.isAttributeNamesValid()) {

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

                ExportAttribute attr = exportAttributes.get(i);

                String newName = attr.getNewName();

                if (!this.namesTranslator.isValidName(this, i, newName)) {

                    String sug = this.namesTranslator.getNameSuggestion(this, i, newName);

                    attr.setNewName(sug);

                }

            }

            if (n > 5000) {

                LOGGER.warn("Not been able to fix attribute field names, it will require a manual operation");

                break;

            }

            n += 1;

        }

    }

    @Override

    public ExportAttributes clone() throws CloneNotSupportedException {

        DefaultExportAttributes clone = (DefaultExportAttributes) super.clone();

        this.namesTranslator.clone();

        clone.setNamesTranslator(this.namesTranslator.clone());

        List cloneListAttribute = new ArrayList();

        for (ExportAttribute exportAttribute : exportAttributes) {

            cloneListAttribute.add(exportAttribute.clone());

        }

        clone.setExportAttributes(cloneListAttribute);

        return clone;

    }

    @Override

    public void setExportAttributes(List<ExportAttribute> exportAttributes) {

        this.exportAttributes = exportAttributes;

    }

    @Override

    public void setActive(boolean active) {

        this.active = active;

    }

    @Override

    public boolean isActive() {

        return this.active;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition = manager.addDefinition(DefaultExportAttributes.class,

                    "ExportAttributes", "ExportAttributes persistence definition", null, null);

            definition.addDynFieldList("exportAttributes").setClassOfItems(ExportAttribute.class);

            definition.addDynFieldObject("namesTranslator").setClassOfValue(AttributeNamesTranslator.class);

            definition.addDynFieldObject("sourceFeatureType").setClassOfValue(FeatureType.class);

            definition.addDynFieldBoolean("active");

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("exportAttributes", this.exportAttributes.iterator());

        state.set("namesTranslator", this.namesTranslator);

        state.set("sourceFeatureType", this.sourceFeatureType);

        state.set("active", this.active);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        Iterator it = state.getIterator("exportAttributes");

        List<ExportAttribute> data = new ArrayList<ExportAttribute>();

        while (it.hasNext()) {

            ExportAttribute ref = (ExportAttribute) it.next();

            data.add(ref);

        }

        this.exportAttributes = data;

        AttributeNamesTranslator nameTranslatorState = (AttributeNamesTranslator) state.get("namesTranslator");

        if (nameTranslatorState != null) {

            this.namesTranslator = nameTranslatorState;

        }

        this.sourceFeatureType = (FeatureType) state.get("sourceFeatureType");

        this.active = state.getBoolean("active");

    }