Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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.fmap.dal.feature.impl;

import java.text.MessageFormat;

import java.util.Iterator;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataTypeUtils;

import org.gvsig.fmap.dal.exception.DataListException;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureAttributeEmulator;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.exception.FeatureTypeIntegrityException;

import static org.gvsig.fmap.dal.feature.impl.DefaultFeatureAttributeDescriptor.NOTIFICATION_FIXED_CHANGED;

import org.gvsig.fmap.dal.impl.DefaultDataManager;

import org.gvsig.json.Json;

import org.gvsig.json.JsonManager;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.json.SupportToJson;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

@SuppressWarnings("UseSpecificCatch")

public class DefaultEditableFeatureType extends DefaultFeatureType implements

        EditableFeatureType, Observer {

    /**

     *

     */

    private static final long serialVersionUID = -713976880396024389L;

    private boolean hasStrongChanges;

    private DefaultFeatureType source;

    public DefaultEditableFeatureType(FeatureStore store) {

        super(store);

        this.hasStrongChanges = false;

        this.source = null;

    }

    public DefaultEditableFeatureType(FeatureStore store, String id) {

        super(store, id);

        this.hasStrongChanges = false;

        this.source = null;

    }

    protected DefaultEditableFeatureType(DefaultEditableFeatureType other) {

        super(other);

        this.hasStrongChanges = other.hasStrongChanges;

        this.source = (DefaultFeatureType) other.getSource();

    }

    protected DefaultEditableFeatureType(DefaultFeatureType other) {

        super(other);

        this.source = other;

        this.fixAll();

    }

    @Override

    protected DefaultFeatureAttributeDescriptor getCopyAttributeDescriptor(DefaultFeatureAttributeDescriptor src) {

        DefaultFeatureAttributeDescriptor copy = new DefaultEditableFeatureAttributeDescriptor(src);

        copy.setFeatureType(this);

        return copy;

    }

    @Override

    public void forceStrongChanges() {

        this.hasStrongChanges = true;

    }

    public boolean hasStrongChanges() {

        if (hasStrongChanges) {

            return true;

        }

        Iterator iter = this.iterator();

        DefaultEditableFeatureAttributeDescriptor attr;

        while (iter.hasNext()) {

            attr = (DefaultEditableFeatureAttributeDescriptor) iter.next();

            if (attr.isComputed()) {

                continue;

            }

            if (attr.hasStrongChanges()) {

                return true;

            }

        }

        return false;

    }

    @Override

    public FeatureType getCopy() {

        DefaultEditableFeatureType copy = new DefaultEditableFeatureType(this);

        copy.fixAll();

        return copy;

    }

    @Override

    public EditableFeatureType getEditable() {

        return (EditableFeatureType) this.getCopy();

    }

    public boolean addAll(DefaultFeatureType other) {

        Iterator iter = other.iterator();

        DefaultFeatureAttributeDescriptor attr;

        DefaultEditableFeatureAttributeDescriptor editableAttr;

        while (iter.hasNext()) {

            attr = (DefaultFeatureAttributeDescriptor) iter.next();

            if (attr instanceof DefaultEditableFeatureAttributeDescriptor) {

                editableAttr = new DefaultEditableFeatureAttributeDescriptor(

                        attr);

            } else {

                editableAttr = new DefaultEditableFeatureAttributeDescriptor(

                        attr);

            }

            editableAttr.addObserver(this);

            super.add(editableAttr);

        }

        this.pk = null;

        this.fixAll();

        return true;

    }

    @Override

    public EditableFeatureAttributeDescriptor addLike(

            FeatureAttributeDescriptor other) {

        DefaultEditableFeatureAttributeDescriptor editableAttr;

        editableAttr = new DefaultEditableFeatureAttributeDescriptor(

                (DefaultFeatureAttributeDescriptor) other);

        super.add(editableAttr);

        if (!editableAttr.isComputed()) {

            this.hasStrongChanges = true;

        }

        editableAttr.addObserver(this);

        this.fixAll();

        return editableAttr;

    }

    @Override

    public FeatureType getSource() {

        return source;

    }

    @Override

    public FeatureType getNotEditableCopy() {

        this.fixAll();

        DefaultFeatureType copy = new DefaultFeatureType(this, false);

        Iterator iter = this.iterator();

        DefaultFeatureAttributeDescriptor attr;

        while (iter.hasNext()) {

            attr = (DefaultFeatureAttributeDescriptor) iter.next();

            DefaultFeatureAttributeDescriptor newattr = new DefaultFeatureAttributeDescriptor(attr);

            newattr.setFeatureType(copy);

            copy.add(newattr);

        }

        copy.fixAll();

        return copy;

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, int type) {

        return this.add(name, type, true);

    }

    @Override

    public void removeAll() {

        while (!super.isEmpty()) {

            FeatureAttributeDescriptor attr = this.get(0);

            if(attr instanceof Observable){

                ((Observable) attr).deleteObserver(this);

            }

            super.remove(0);

        }

        this.fixAll();

    }

    @Override

    public void addAll(FeatureType attributes) {

        super.addAll(attributes);

        this.fixAll();

    }

    private EditableFeatureAttributeDescriptor add(String name, int type, boolean strongChanges) {

        Iterator iter = this.iterator();

        while (iter.hasNext()) {

            EditableFeatureAttributeDescriptor descriptor = (EditableFeatureAttributeDescriptor) iter.next();

            if (descriptor.getName().equalsIgnoreCase(name)) {

                throw new IllegalArgumentException(

                        MessageFormat.format("Duplicated name descriptor {0}.", name)

                );

            }

        }

        DefaultEditableFeatureAttributeDescriptor attr = DefaultDataManager.createEditableFeatureAttributeDescriptor(this, name, type, strongChanges);

        attr.setIndex(this.size());

        this.hasStrongChanges = this.hasStrongChanges || strongChanges;

        super.add(attr);

        this.pk = null;

        attr.addObserver(this);

        this.fixed = false;

        return attr;

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, int type, int size) {

        return this.add(name, type, true).setSize(size);

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, int type,

            Evaluator evaluator) {

        if (evaluator == null) {

            throw new IllegalArgumentException();

        }

        return this.add(name, type, false).setEvaluator(evaluator);

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, int type,

            FeatureAttributeEmulator emulator) {

        if (emulator == null) {

            throw new IllegalArgumentException();

        }

        return this.add(name, type, false).setFeatureAttributeEmulator(emulator);

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, String type) {

        return this.add(name, ToolsLocator.getDataTypesManager().getType(type));

    }

    @Override

    public EditableFeatureAttributeDescriptor add(String name, String type, int size) {

        return this.add(name, ToolsLocator.getDataTypesManager().getType(type), size);

    }

    public Object removeAttributeDescriptor(String name) {

//    Hemos metido los metodos removeAttributeDescriptor ya que existe

//    un problema desde python al llamar a los metodos remove. En lugar de llamar

//    a estos metodos remove, llama a los de la superclase ArrayList.

        return this.remove(name);

    }

    public boolean removeAttributeDescriptor(EditableFeatureAttributeDescriptor attribute) {

        return this.remove(attribute);

    }

    @Override

    public FeatureAttributeDescriptor remove(int index) {

        FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.get(index);

        if (!attr.isComputed()) {

            hasStrongChanges = true;

        }

        if (index == this.getDefaultGeometryAttributeIndex()) {

            this.defaultGeometryAttributeIndex = -1;

            this.defaultGeometryAttributeName = null;

        } else if (index == this.getDefaultTimeAttributeIndex()) {

            this.defaultTimeAttributeIndex = -1;

            this.defaultTimeAttributeName = null;

        }

        super.remove(attr);

        this.fixed = false;

        this.pk = null;

        if(attr instanceof Observable){

            ((Observable) attr).deleteObserver(this);

        }

        this.fixAll();

        return attr;

    }

    @Override

    public Object remove(String name) {

        FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.get(name);

        if (attr == null) {

            return null;

        }

        this.remove(attr.getIndex());

        return attr;

    }

    @Override

    public boolean remove(EditableFeatureAttributeDescriptor attribute) {

        this.remove(attribute.getIndex());

        return true;

    }

    @Override

    protected void fixAll() {

        if(this.fixed){

            return;

        }

        super.fixAll();

        for (FeatureAttributeDescriptor attr : this) {

            if (attr instanceof DefaultEditableFeatureAttributeDescriptor) {

                DefaultEditableFeatureAttributeDescriptor attr2 = (DefaultEditableFeatureAttributeDescriptor) attr;

                if (attr2.hasStrongChanges()) {

                    this.hasStrongChanges = true;

                    break;

                }

            }

        }

        this.fixed = true;

    }

    public void checkIntegrity() throws DataListException {

        Iterator iter = super.iterator();

        FeatureTypeIntegrityException ex = null;

        while (iter.hasNext()) {

            DefaultEditableFeatureAttributeDescriptor attr = (DefaultEditableFeatureAttributeDescriptor) iter

                    .next();

            try {

                attr.checkIntegrity();

            } catch (Exception e) {

                if (ex == null) {

                    ex = new FeatureTypeIntegrityException(this.getId());

                }

                ex.add(e);

            }

        }

        if (ex != null) {

            throw ex;

        }

    }

    @Override

    public void setDefaultGeometryType(int type, int subType) {

        EditableFeatureAttributeDescriptor descr = (EditableFeatureAttributeDescriptor) this.getDefaultGeometryAttribute();

        if (descr == null) {

            throw new IllegalStateException("Default geometry attribute not set.");

        }

        descr.setGeometryType(type, subType);

        this.fixed = false;

    }

    @Override

    public void setDefaultGeometryAttributeName(String name) {

        if (name == null || name.length() == 0) {

            this.defaultGeometryAttributeName = null;

            this.defaultGeometryAttributeIndex = -1;

            this.fixed = false;

            return;

        }

        FeatureAttributeDescriptor attr = this.getAttributeDescriptor(name);

        if (attr == null) {

            throw new IllegalArgumentException("Attribute '" + name + "' not found.");

        }

        this.defaultGeometryAttributeName = name;

        this.defaultGeometryAttributeIndex = attr.getIndex();

        this.fixed = false;

    }

    @Override

    public int getDefaultGeometryAttributeIndex() {

        this.fixAll();

        return this.defaultGeometryAttributeIndex;

    }

    @Override

    public String getDefaultGeometryAttributeName() {

        this.fixAll();

        return this.defaultGeometryAttributeName;

    }

    @Override

    public FeatureAttributeDescriptor getDefaultGeometryAttribute() {

        this.fixAll();

        return super.getDefaultGeometryAttribute();

    }

    @Override

    public int getDefaultTimeAttributeIndex() {

        this.fixAll();

        return this.defaultTimeAttributeIndex;

    }

    @Override

    public String getDefaultTimeAttributeName() {

        this.fixAll();

        return this.defaultTimeAttributeName;

    }

    @Override

    public void setHasOID(boolean hasOID) {

        this.hasOID = hasOID;

        this.fixed = false;

    }

    @Override

    protected Iterator getIterator(Iterator iter) {

        return new EditableDelegatedIterator(iter, this);

    }

    @Override

    public EditableFeatureAttributeDescriptor getEditableAttributeDescriptor(String name) {

        return (EditableFeatureAttributeDescriptor) this.getAttributeDescriptor(name);

    }

    @Override

    public EditableFeatureAttributeDescriptor getEditableAttributeDescriptor(int index) {

        return (EditableFeatureAttributeDescriptor) this.getAttributeDescriptor(index);

    }

    @Override

    public void setCheckFeaturesAtFinishEditing(boolean check) {

        this.checkFeaturesAtFinishEditing = check;

        this.fixed = false;

    }

    @Override

    public void setCheckFeaturesAtInsert(boolean check) {

        this.checkFeaturesAtInsert = check;

        this.fixed = false;

    }

    protected class EditableDelegatedIterator extends DelegatedIterator {

        private final DefaultEditableFeatureType fType;

        public EditableDelegatedIterator(Iterator iter, DefaultEditableFeatureType fType) {

            super(iter);

            this.fType = fType;

        }

        @Override

        public void remove() {

            this.iterator.remove();

            this.fType.fixAll();

        }

    }

    protected void setAllowAutomaticValues(boolean value) {

        this.allowAtomaticValues = value;

        this.fixed = false;

    }

    @Override

    public void copyFrom(FeatureType other) {

        super.copyFrom(other);

        if (other instanceof EditableFeatureType) {

            DefaultEditableFeatureType other2 = (DefaultEditableFeatureType) other;

            this.hasStrongChanges = other2.hasStrongChanges();

            this.source = (DefaultFeatureType) other2.getSource();

        } else {

            this.hasStrongChanges = false;

            this.source = (DefaultFeatureType) other;

        }

        this.fixed = false;

    }

    public void copyFrom(JsonObject json) {

        // TODO: falta por implementar copyFrom(json)

        this.fixed = false;

    }

    @Override

    public void set(String name, String value) {

        if (StringUtils.isBlank(name)) {

            throw new IllegalArgumentException("Name can't be empty");

        }

        switch (name.trim().toLowerCase()) {

            case "checkfeaturesatfinishediting":

                this.setCheckFeaturesAtFinishEditing(DataTypeUtils.toBoolean(value, false));

                break;

            case "checkfeaturesatinsert":

                this.setCheckFeaturesAtInsert(DataTypeUtils.toBoolean(value, false));

                break;

            case "defaultgeometryattributename":

            case "defaultgeometryname":

            case "defaultgeometry":

                this.setDefaultGeometryAttributeName(DataTypeUtils.toString(value, null));

                break;

            default:

                throw new IllegalArgumentException("Name attribute '" + name + "' not valid.");

        }

        this.fixed = false;

    }

    private static class TheJsonSerializer implements JsonManager.JsonSerializer {

        public TheJsonSerializer() {

        }

        @Override

        public Class getObjectClass() {

            return DefaultEditableFeatureType.class;

        }

        @Override

        public Object toObject(JsonObject json) {

            EditableFeatureType o = new DefaultFeatureType().getEditable();

            o.fromJson(json);

            return o;

        }

        @Override

        public JsonObjectBuilder toJsonBuilder(Object value) {

            return ((SupportToJson)value).toJsonBuilder();

        }

    }

    public static void selfRegister() {

        Json.registerSerializer(new TheJsonSerializer());

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (notification instanceof Notification && observable instanceof DefaultFeatureAttributeDescriptor){

            DefaultFeatureAttributeDescriptor attr = (DefaultFeatureAttributeDescriptor) observable;

            Notification n = (Notification) notification;

            if(n.isOfType(NOTIFICATION_FIXED_CHANGED)){

                if(!attr.isFixed()) {

                    this.fixed = false;

                }

            }

        }

    }

}