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.math.BigDecimal;

import java.text.DateFormat;

import java.util.HashMap;

import java.util.Locale;

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

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.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.dynobject.DynField;

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(DataType dataType) {

        updateStrongChanges(this.dataType, dataType);

        this.dataType = dataType;

        return this;

    }

    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

        );

        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;

    }

    @Override

    public EditableFeatureAttributeDescriptor setPrecision(int precision) {

        updateStrongChanges(this.precision, precision);

        this.precision = precision;

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setScale(int scale) {

        updateStrongChanges(this.scale, scale);

        this.scale = scale;

        this.coerceContext = null;

        this.mathContext = null;

        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.setReadOnly(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;

    }

    @Override

    public EditableFeatureAttributeDescriptor setLocale(Locale locale) {

      if( locale == null ) {

        this.locale = Locale.ENGLISH;

      } else {

        this.locale = locale;

      }

      this.coerceContext = null;

      this.mathContext = null;

      return this;

    }

    public EditableFeatureAttributeDescriptor setLocale(String locale) {

      Locale l;

      try {

        String s = DataTypeUtils.toString(locale, null);

        if( StringUtils.isBlank(s) ) {

          return this.setLocale((Locale)null);

        }

        l = new Locale(s);

        return this.setLocale(l);

      } catch(Exception ex) {

          return this.setLocale((Locale)null);

      }

    }

    @Override

    public EditableFeatureAttributeDescriptor setRoundMode(int roundMode) {

      switch(roundMode) {

        case BigDecimal.ROUND_UP:

        case BigDecimal.ROUND_DOWN:

        case BigDecimal.ROUND_CEILING:

        case BigDecimal.ROUND_FLOOR:

        case BigDecimal.ROUND_HALF_UP:

        case BigDecimal.ROUND_HALF_DOWN:

        case BigDecimal.ROUND_HALF_EVEN:

        case BigDecimal.ROUND_UNNECESSARY:

          this.roundMode = roundMode;

          this.coerceContext = null;

          this.mathContext = null;

          break;

        default:

          throw new IllegalArgumentException("round mode '"+roundMode+"' not valid.");

      }

      return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor set(String name, Object value) {

        if( StringUtils.isBlank(name)) {

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

        }

        switch(name.toLowerCase()) {

            case "isreadonly":

            case "readonly":

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

                break;

            case "hidden":

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

                break;

            case "allownull":

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

                break;

            case "pk":

            case "ispk":

            case "primarykey":

            case "isprimarykey":

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

                break;

            case "isautomatic":

            case "automatic":

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

                break;

            case "time":

            case "istime":

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

                break;

            case "profile":

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

                break;

            case "group":

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

                break;

            case "description":

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

                break;

            case "label":

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

                break;

            case "shortlabel":

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

                break;

            case "expression":

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

                break;

            case "size":

                this.setSize(DataTypeUtils.toInteger(value, 50));

                break;

            case "precision":

                this.setPrecision(DataTypeUtils.toInteger(value, 10));

                break;

            case "scale":

                this.setScale(DataTypeUtils.toInteger(value, 10));

                break;

            case "roundmode":

              this.setRoundMode(DataTypeUtils.toInteger(value, BigDecimal.ROUND_UNNECESSARY));

              break;

            case "locale":

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

              break;

            case "order":

                this.setOrder(DataTypeUtils.toInteger(value, 0));

                break;

            case "foreingkey":

                this.getForeingKey().setForeingKey(DataTypeUtils.toBoolean(value, false));

                break;

            case "foreingkey.code":

                this.getForeingKey().setCodeName(DataTypeUtils.toString(value, ""));

                break;

            case "foreingkey.label":

                this.getForeingKey().setLabelFormula(DataTypeUtils.toString(value, ""));

                break;

            case "foreingkey.closedlist":

                this.getForeingKey().setClosedList(DataTypeUtils.toBoolean(value, false));

                break;

            case "foreingkey.table":

                this.getForeingKey().setTableName(DataTypeUtils.toString(value, null));

                break;

            case "interval":

                this.setInterval(DataTypeUtils.toInterval(value, null));

                break;

            case "geomtype":

            case "geometrytype":

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

                break;

            case "srs":

                this.setSRS(DataTypeUtils.toProjection(value, null));

                break;

            case "relation":

                this.setRelationType(toRelation(value));

                break;

            default:

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

        }

        return this;

    }

    private int toRelation(Object value) {

      if (value == null) {

        return DynField.RELATION_TYPE_NONE;

      }

      Integer x = (Integer) DataTypeUtils.coerce(DataTypes.INT,value, null);

      if (x != null) {

        return x;

      }

      try {

        String s = value.toString().toUpperCase();

        switch (s) {

          case "NONE":

          default:

            return DynField.RELATION_TYPE_NONE;

          case "IDENTITY":

            return DynField.RELATION_TYPE_IDENTITY;

          case "COLLABORATION":

            return DynField.RELATION_TYPE_COLLABORATION;

          case "COMPOSITION":

            return DynField.RELATION_TYPE_COMPOSITION;

          case "AGGREGATE":

            return DynField.RELATION_TYPE_AGGREGATE;

        }

      } catch(Exception ex) {

        return DynField.RELATION_TYPE_NONE;

      }

    }

  @Override

  public EditableFeatureAttributeDescriptor setRequiredBytes(int size) {

    this.requiredBytes = size;

    return this;

  }

}