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.DateFormat;

import java.util.HashMap;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.evaluator.Evaluator;

public class DefaultEditableFeatureAttributeDescriptor extends

    DefaultFeatureAttributeDescriptor implements

    EditableFeatureAttributeDescriptor {

    private static Logger logger = LoggerFactory.getLogger(

        DefaultEditableFeatureAttributeDescriptor.class);

    private final DefaultFeatureAttributeDescriptor source;

    private boolean hasStrongChanges;

    private String originalName = null;

    protected DefaultEditableFeatureAttributeDescriptor(

        DefaultFeatureAttributeDescriptor other) {

        super(other);

        if (other instanceof DefaultEditableFeatureAttributeDescriptor) {

            DefaultEditableFeatureAttributeDescriptor other_edi =

                (DefaultEditableFeatureAttributeDescriptor) other;

            originalName = other_edi.getOriginalName();

            this.source = other_edi.getSource();

        } else {

            this.source = other;

        }

        hasStrongChanges = false;

    }

    public DefaultEditableFeatureAttributeDescriptor(FeatureType type, boolean strongChanges) {

        super(type);

        this.source = null;

        hasStrongChanges = strongChanges;

    }

    public DefaultFeatureAttributeDescriptor getSource() {

        return this.source;

    }

    public void fixAll() {

        super.fixAll();

    }

    public void checkIntegrity() throws AttributeFeatureTypeIntegrityException {

        AttributeFeatureTypeIntegrityException ex =

            new AttributeFeatureTypeIntegrityException(getName());

        if (this.size < 0) {

            ex.add(new AttributeFeatureTypeSizeException(this.size));

        }

        if( this.dataType.isObject() && this.objectClass == null ) {

            logger.warn("Incorrect data type object, objectClass is null.");

            ex.add(new AttributeFeatureTypeIntegrityException(this.name));

        }

        // TODO: Add other integrity checks...

        if (ex.size() > 0) {

            throw ex;

        }

    }

    public EditableFeatureAttributeDescriptor setAllowNull(boolean allowNull) {

        updateStrongChanges(this.allowNull, allowNull);

        this.allowNull = allowNull;

        return this;

    }

    @Override

    public EditableForeingKey getForeingKey() {

        if( this.foreingKey==null ) {

            this.foreingKey = new DefaultForeingKey();

            this.foreingKey.setDescriptor(this);

        }

        return this.foreingKey;

    }

    public EditableFeatureAttributeDescriptor setDataType(int type) {

        updateStrongChanges(this.dataType, type);

        this.dataType = ToolsLocator.getDataTypesManager().get(type);

        return this;

    }

    public EditableFeatureAttributeDescriptor setDefaultValue(

        Object defaultValue) {

        updateStrongChanges(this.defaultValue, defaultValue);

        this.defaultValue = defaultValue;

        return this;

    }

    public EditableFeatureAttributeDescriptor setEvaluator(Evaluator evaluator) {

        updateStrongChanges(this.evaluator, evaluator);

        this.evaluator = evaluator;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(FeatureAttributeEmulator featureAttributeEmulator) {

        this.featureAttributeEmulator = featureAttributeEmulator;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(Expression expression) {

        if( ExpressionUtils.isPhraseEmpty(expression) ) {

            this.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);

            return this;

        } 

        FeatureAttributeEmulatorExpression emulator = DALLocator.getDataManager().createFeatureAttributeEmulatorExpression(

                this.getFeatureType(),

                expression

        );

        if( !emulator.isValid() ) {

            this.setFeatureAttributeEmulator(emulator);

            throw new IllegalArgumentException("Can't create calculated field '"+this.getName()+"', "+emulator.getErrorMessage());

        }

        return this.setFeatureAttributeEmulator(emulator);

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(String expression) {

        if( StringUtils.isBlank(expression) ) {

            this.setFeatureAttributeEmulator((FeatureAttributeEmulator)null);

            return this;

        } 

        return this.setFeatureAttributeEmulator(ExpressionUtils.createExpression(expression));

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(int type) {

        this.geometryType = type;

        if( this.geometrySubType == Geometry.SUBTYPES.UNKNOWN ) {

            this.geometrySubType = Geometry.SUBTYPES.GEOM2D;

        }

        this.geomType = null;

        return this;

    }

    public EditableFeatureAttributeDescriptor setGeometrySubType(int subType) {

        this.geometrySubType = subType;

        this.geomType = null;

        return this;

    }

    public EditableFeatureAttributeDescriptor setGeometryType(

        GeometryType geometryType) {

        updateStrongChanges(this.geomType, geometryType);

        this.geomType = geometryType;

        this.geometryType = this.geomType.getType();

        this.geometrySubType = this.geomType.getSubType();

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(String geometryType) {

        if( StringUtils.isBlank(geometryType) ) {

            throw new IllegalArgumentException("Invalid geometry type (null)");

        }

        String separators = ":/-!;#@";

        Character sep = null;

        for (char ch : separators.toCharArray()) {

            if( geometryType.indexOf(ch)>=0 ) {

                sep = ch;

                break;

            }

        }

        if( sep == null ) {

            throw new IllegalArgumentException("Invalid geometry type ("+geometryType+") can't find separator, format can be GEOMETRYTYPE["+separators+"]GEOMETRYSUBTYPE");

        }

        String[] xx = geometryType.split("["+sep+"]");

        int theGeomType = GeometryUtils.getGeometryType(xx[0]);

        int theGeomSubtype = GeometryUtils.getGeometrySubtype(xx[1]);

        this.setGeometryType(theGeomType, theGeomSubtype);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(int type, int subType) {

        this.geometryType = type;

        this.geometrySubType = subType;

        this.geomType = null;

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsPrimaryKey(

        boolean isPrimaryKey) {

        updateStrongChanges(this.primaryKey, primaryKey);

        this.primaryKey = isPrimaryKey;

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsReadOnly(boolean isReadOnly) {

        updateStrongChanges(this.readOnly, readOnly);

        this.readOnly = isReadOnly;

        return this;

    }

    public EditableFeatureAttributeDescriptor setMaximumOccurrences(

        int maximumOccurrences) {

        updateStrongChanges(this.maximumOccurrences, maximumOccurrences);

        this.maximumOccurrences = maximumOccurrences;

        return this;

    }

    public EditableFeatureAttributeDescriptor setMinimumOccurrences(

        int minimumOccurrences) {

        updateStrongChanges(this.minimumOccurrences, minimumOccurrences);

        this.minimumOccurrences = minimumOccurrences;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setName(String name) {

        if( StringUtils.equalsIgnoreCase(this.name, name) ) {

            return this;

        }

        if (originalName == null) {

            originalName = this.name;

            if (!isComputed()) {

                hasStrongChanges = true;

            }

        }

        super.setName(name);

        if (!isComputed()) {

            hasStrongChanges = true;

        }

        return this;

    }

    public String getOriginalName() {

        return originalName;

    }

    public EditableFeatureAttributeDescriptor setObjectClass(Class theClass) {

        updateStrongChanges(this.objectClass, theClass);

        this.objectClass = theClass;

        return this;

    }

    public EditableFeatureAttributeDescriptor setPrecision(int precision) {

        updateStrongChanges(this.precision, precision);

        this.precision = precision;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setSRS(IProjection SRS) {

        updateStrongChanges(this.SRS, SRS);

        this.SRS = SRS;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setSRS(String SRS) {

        if( StringUtils.isBlank(SRS) ) {

            this.setSRS((IProjection)null);

            return this;

        }

        IProjection proj = CRSFactory.getCRS(SRS);

        this.setSRS(proj);

        return this;

    }

    public EditableFeatureAttributeDescriptor setInterval(Interval interval) {

        updateStrongChanges(this.getInterval(), interval);

        super.setInterval(interval);

        return this;

    }

    public EditableFeatureAttributeDescriptor setSize(int size) {

        updateStrongChanges(this.size, size);

        this.size = size;

        return this;

    }

    public boolean hasStrongChanges() {

        return hasStrongChanges;

    }

    public EditableFeatureAttributeDescriptor setAdditionalInfo(

        String infoName, Object value) {

        if (this.additionalInfo == null) {

            this.additionalInfo = new HashMap();

        }

        this.additionalInfo.put(infoName, value);

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsAutomatic(boolean isAutomatic) {

        this.isAutomatic = isAutomatic;

        if( isAutomatic ) {

            this.setHidden(true);

        }

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsTime(boolean isTime) {

        updateStrongChanges(this.isTime, isTime);

        this.isTime = isTime;

        return this;

    }

    public EditableFeatureAttributeDescriptor setDateFormat(DateFormat dateFormat) {

        this.dateFormat = dateFormat;

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsIndexed(boolean isIndexed) {

        updateStrongChanges(this.indexed, isIndexed);

        this.indexed = isIndexed;

        return this;

    }

    public EditableFeatureAttributeDescriptor setAllowIndexDuplicateds(boolean allowDuplicateds) {

        updateStrongChanges(this.allowIndexDuplicateds, allowDuplicateds);

        this.allowIndexDuplicateds = allowDuplicateds;

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsIndexAscending(boolean ascending) {

        updateStrongChanges(this.isIndexAscending, ascending);

        this.isIndexAscending = ascending;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setDataProfileName(String dataProfile) {

        super.setDataProfileName(dataProfile);

        return this;

    }

    private void updateStrongChanges(int previous, int newvalue) {

        if( isComputed() ) {

            return;

        }

        if( previous == newvalue ) {

            return;

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(DataType previous, int newvalue) {

        if( isComputed() ) {

            return;

        }

        if( previous!=null ) {

            if( previous.getType() == newvalue ) {

                return;

            }

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(boolean previous, boolean newvalue) {

        if( isComputed() ) {

            return;

        }

        if( previous == newvalue ) {

            return;

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(Object previous, Object newvalue) {

        if( isComputed() ) {

            return;

        }

        if( Objects.equals(newvalue, previous) ) {

            return;

        }

        this.hasStrongChanges = true;

    }

}