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.lang.ref.WeakReference;

import java.math.BigDecimal;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.function.Predicate;

import javax.json.JsonObject;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.SupportTransactions;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.dynobjectutils.DynObjectFeatureFacade;

import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.json.Json;

import org.gvsig.json.JsonArrayBuilder;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.BaseRuntimeException;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.util.Bitmask;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeature implements Feature, EvaluatorData, Cloneable {

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

    private static DataTypesManager dataTypesManager = null;

    protected FeatureProvider data;

    protected FeatureReference reference;

    private WeakReference storeRef;

    private boolean inserted = false;

    private Object[] extraValuesData;

    private Map<String, Object> extraValues; // not persistent

    /*

         * Usar con mucha precaucion o mejor no usar. Lo precisa el

         * DefaultFeatureSet en la ordenacion.

     */

    public DefaultFeature(FeatureStore store) {

        this.storeRef = new WeakReference(store);

        this.reference = null;

    }

    public DefaultFeature(FeatureStore store, FeatureProvider data) {

        this.data = data;

        this.extraValuesData = null;

        this.storeRef = new WeakReference(store);

        this.reference = null;

        this.inserted = !data.isNew();

    }

    DefaultFeature(DefaultFeature feature) {

        this.data = feature.data.getCopy();

        this.extraValuesData = ArrayUtils.clone(feature.extraValuesData);

        this.storeRef = feature.storeRef;

        this.reference = feature.reference;

        this.inserted = feature.isInserted();

    }

    public DefaultFeature(FeatureType targetType, Feature sourceFeature) {

        DefaultFeature defaultFeature = (DefaultFeature) sourceFeature;

        this.data = new DefaultFeatureProvider(targetType, (DefaultFeatureProvider) defaultFeature.getData());

        this.extraValuesData = null;

        this.storeRef = defaultFeature.storeRef;

        this.reference = defaultFeature.reference;

        this.inserted = defaultFeature.isInserted();

        FeatureType sourceType = sourceFeature.getType();

        for (FeatureAttributeDescriptor targetAttrDescriptor : targetType) {

            if (targetAttrDescriptor.isComputed()) {

                continue;

            }

            int sourceIndex = sourceType.getIndex(targetAttrDescriptor.getName());

            if (sourceIndex < 0) {

                continue;

            }

            Object value = sourceFeature.get(sourceIndex);

            if (value == null && !targetAttrDescriptor.allowNull()) {

                continue;

            }

            this.setforced(targetAttrDescriptor.getIndex(), targetAttrDescriptor, value);

        }

    }

    public void setData(FeatureProvider data) {

        this.data = data;

        this.extraValuesData = null;

        this.reference = null;

        this.inserted = true;

    }

    public FeatureProvider getData() {

        return this.data;

    }

    protected DataTypesManager getDataTypesManager() {

        if (dataTypesManager == null) {

            dataTypesManager = ToolsLocator.getDataTypesManager();

        }

        return dataTypesManager;

    }

    public boolean canSetValue(String name) {

        return this.canSetValue(this.getType().getAttributeDescriptor(name), null);

    }

    public boolean canSetValue(FeatureAttributeDescriptor attr,Predicate<FeatureAttributeDescriptor> copy) {

        // helper function to use in copyFrom

        if (attr==null  ) {

            return false;

        }

        if (attr.isAutomatic()  || attr.isComputed() ) {

            return false;

        }

        if( this.isInserted() &&  attr.isReadOnly()) {

            return false;

        }

        if( copy!=null && !copy.test(attr) ) {

            return false;

        }

        return true;

    }

    protected void set(FeatureAttributeDescriptor attribute, Object value) {

        int i = attribute.getIndex();

        if( this.isInserted() ) {

            if (attribute.isReadOnly()) {

                throw new SetReadOnlyAttributeException(attribute.getName(), this.getType());

            }

        } else {

            if (attribute.isComputed()) {

                throw new SetReadOnlyAttributeException(attribute.getName(), this.getType());

            }

        }

        FeatureAttributeEmulator emulator = attribute.getFeatureAttributeEmulator();

        if (emulator != null) {

            emulator.set((EditableFeature) this, value);

            return;

        }

        if (value == null) {

            if (!attribute.allowNull()) {

                if (!attribute.isAutomatic()) {

                    throw new IllegalValueException(attribute, value);

                }

            }

            this.data.set(i, null);

            return;

        }

        if (attribute.getFeatureAttributeGetter() != null) {

            value = attribute.getFeatureAttributeGetter().setter(value);

        }

        this.setforced(i, attribute, value);

    }

    private void setforced(int i, FeatureAttributeDescriptor attribute, Object value) {

        Class objectClass = attribute.getObjectClass();

        if (objectClass != null) {

            if (objectClass.isInstance(value)) {

                if (attribute.getType() == DataTypes.DECIMAL) {

                    BigDecimal d = (BigDecimal) value;

                    if (d.scale() == attribute.getScale() && d.precision() <= attribute.getPrecision()) {

                        this.data.set(i, value);

                        return;

                    }

                } else if (attribute.getType() == DataTypes.GEOMETRY) {

                    if (!attribute.getGeomType().equals(((Geometry) value).getGeometryType())) {

                        try {

                            Coercion coercer = attribute.getDataType().getCoercion();

                            value = coercer.coerce(value, attribute.getCoercionContext());

                        } catch (CoercionException e) {

                            throw new IllegalArgumentException("Can't convert to "

                                    + attribute.getDataType().getName()

                                    + " from '"

                                    + value == null ? "NULL" : value.getClass().getName()

                                            + "' with value '"

                                            + Objects.toString(value)

                                            + "' and context '"

                                            + attribute.getCoercionContext()

                                            + "'.",e);

                        }

                    } 

                    this.data.set(i, value);

                    return;

                } else {

                    this.data.set(i, value);

                    return;

                }

            }

            DataProfile dataProfile = attribute.getDataProfile();

            if (dataProfile != null) {

                try {

                    value = dataProfile.coerce(

                            attribute.getDataType(),

                            value,

                            attribute.getTags()

                    );

                } catch (CoercionException e) {

                }

            }

            try {

                Coercion coercer = attribute.getDataType().getCoercion();

                if (attribute.getType() == DataTypes.STRING && value instanceof Boolean) {

                    value = coercer.coerce(value, attribute.getCoercionContext());

                    value = StringUtils.left((String) value, attribute.getSize());

                } else {

                    value = coercer.coerce(value, attribute.getCoercionContext());

                }

            } catch (CoercionException e) {

                throw new IllegalArgumentException("Can't assign value [" + 

                        toStringQuietly(value)+

                        "] of type '"+

                        (value == null ? "NULL" : value.getClass().getName())+

                        "' to field '"+

                        attribute.getName()+

                        "' of type "+

                        attribute.getDataType().getName()+

                        "."

                ,e);

            }

        }

        this.data.set(i, value);

    }

    private String toStringQuietly(Object v) {

        try {

            return Objects.toString(v);

        } catch(Throwable t) {

            return "ERROR";

        }

    }

    private Object get(int index, Class theClass, int type) {

        Object value = this.get(index);

        if (theClass.isInstance(value)) {

            return value;

        }

        try {

            return this.getDataTypesManager().coerce(type, value, this.getType().getAttributeDescriptor(index).getCoercionContext());

        } catch (CoercionException e) {

            if (value == null) {

                return null;

            }

            throw new IllegalArgumentException(

                    "Can't convert to " + theClass.getName()

                    + " from '" + value.getClass().getName()

                    + "' with value '" + value.toString() + "'.");

        }

    }

    public void initializeValues() {

        FeatureType type = this.getType();

        for (FeatureAttributeDescriptor attribute : type) {

            if (attribute.isAutomatic() || attribute.isReadOnly()

                    || attribute.isComputed()) {

                continue;

            }

            if (attribute.getDefaultValue() == null && !attribute.allowNull()) {

                continue;

            }

            Object value = attribute.getDefaultValue();

            if (value instanceof CharSequence) {

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

                if (ExpressionUtils.isDynamicText(s)) {

                    try {

                        value = ExpressionUtils.evaluateDynamicText(s);

                    } catch (Throwable th) {

                        value = null;

                    }

                }

            }

            this.set(attribute, value);

        }

    }

    public void clear() {

        initializeValues();

    }

    public void initializeValues(Feature feature) {

        FeatureType myType = this.getType();

        FeatureType type = feature.getType();

        extraValuesData = null;

        for (FeatureAttributeDescriptor attribute : type) {

            FeatureAttributeDescriptor myAttribute = myType.getAttributeDescriptor(attribute.getName());

            if (myAttribute != null) {

                this.set(myAttribute, feature.get(attribute.getIndex()));

            }

        }

    }

    @Override

    public FeatureStore getStore() {

        return (FeatureStore) this.storeRef.get();

    }

    @Override

    public FeatureType getType() {

        return this.data.getType();

    }

    @Override

    public EditableFeature getEditable() {

        return new DefaultEditableFeature(this);

    }

    @Override

    public Feature getCopy() {

        return new DefaultFeature(this);

    }

    @Override

    @SuppressWarnings("CloneDoesntCallSuperClone")

    public Object clone() throws CloneNotSupportedException {

        return new DefaultFeature(this);

    }

    @Override

    public FeatureReference getReference() {

        if(!this.getType().supportReferences()){

            return null;

        }

        if (this.reference == null) {

            if (!isInserted()) {

                return null;

            }

            reference = FeatureReferenceFactory.createFromFeature(this);

        }

        return this.reference;

    }

    @Override

    public Object getOrDefault(String name, Object defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        return this.get(index);

    }

    @Override

    public Object getOrDefault(String name, int type, Object defaultValue) {

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

        return getOrDefault(name, dataType, defaultValue);

    }

    @Override

    public Object getOrDefault(String name, DataType type, Object defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            Object value = this.get(index);

            if(value == null){

                return defaultValue;

            }

            return type.coerce(value);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public String getStringOrDefault(String name, String defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return (String) this.get(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public boolean getBooleanOrDefault(String name, boolean defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getBoolean(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public int getIntOrDefault(String name, int defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getInt(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public long getLongOrDefault(String name, long defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getLong(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public float getFloatOrDefault(String name, float defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getFloat(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public double getDoubleOrDefault(String name, double defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getDouble(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public BigDecimal getDecimalOrDefault(String name, BigDecimal defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getDecimal(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public Date getDateOrDefault(String name, Date defaultValue) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            return defaultValue;

        }

        try {

            return this.getDate(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public Object getOrDefault(int index, Object defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.get(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public String getStringOrDefault(int index, String defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getString(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public boolean getBooleanOrDefault(int index, boolean defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getBoolean(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public int getIntOrDefault(int index, int defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getInt(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public long getLongOrDefault(int index, long defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getLong(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public float getFloatOrDefault(int index, float defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getFloat(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public double getDoubleOrDefault(int index, double defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getDouble(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public BigDecimal getDecimalOrDefault(int index, BigDecimal defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getDecimal(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public Date getDateOrDefault(int index, Date defaultValue) {

        if (index < 0 || index >= this.data.getType().size()) {

            return defaultValue;

        }

        try {

            return this.getDate(index);

        } catch (Throwable th) {

            return defaultValue;

        }

    }

    @Override

    public void validate(int check) throws DataException {

        ((DefaultFeatureType) this.data.getType()).validateFeature(this, check);

    }

    @Override

    public boolean isBroken() {

        return this.data.isBroken();

    }

    class UnableToGetReferenceException extends BaseRuntimeException {

        /**

         *

         */

        private static final long serialVersionUID = 1812805035204824163L;

        /**

         * @param exception

         */

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UnableToGetReferenceException(BaseException exception) {

            super("Unable to get reference", "_UnableToGetReferenceException",

                    serialVersionUID);

            this.initCause(exception);

        }

    }

    @Override

    public List getSRSs() {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public Envelope getDefaultEnvelope() {

        Envelope envelope = this.data.getDefaultEnvelope();

        if (envelope == null) {

            int i = this.data.getType().getDefaultGeometryAttributeIndex();

            if (i < 0) {

                return null;

            }

            Geometry geom = this.getDefaultGeometry();

            if (geom != null) {

                envelope = geom.getEnvelope();

            }

        }

        return envelope;

    }

    @Override

    public Geometry getDefaultGeometry() {

        Geometry geom = this.data.getDefaultGeometry();

        if (geom == null) {

            int i = this.data.getType().getDefaultGeometryAttributeIndex();

            if (i < 0) {

                return null;

            }

            Object x = this.get(i);

            if (x instanceof Geometry) {

                geom = (Geometry) x;

            } else {

                geom = this.getGeometry(i);

            }

        }

        if (geom != null) {

            if (geom.getProjection() == null) {

                FeatureType type = this.getType();

                DefaultFeatureAttributeDescriptor attrdesc = (DefaultFeatureAttributeDescriptor) type.get(type.getDefaultGeometryAttributeIndex());

                IProjection proj = attrdesc.getSRS(this.storeRef);

                geom.setProjection(proj);

            }

        }

        return geom;

    }

//    @Override

//    public Time getDefaultTime() {

//            Time time = this.data.getDefaultTime();

//        if( time == null ) {

//            int i = this.data.getType().getDefaultTimeAttributeIndex();

//            Object x = this.get(i);

//            if( x instanceof Time ) {

//                time = (Time) x;

//            } else {

//                time = this.getTime(i);

//            }

//        }

//        return time;

//    }

//

    @Override

    public IProjection getDefaultSRS() {

        IProjection srs = this.data.getType().getDefaultSRS();

        if (srs == null) {

            FeatureType type = this.getType();

            DefaultFeatureAttributeDescriptor attrdesc = (DefaultFeatureAttributeDescriptor) type.get(type.getDefaultGeometryAttributeIndex());

            srs = attrdesc.getSRS(this.storeRef);

        }

        return srs;

    }

    @Override

    public List getGeometries() {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public Object getFromProfile(int index) {

        FeatureAttributeDescriptor descriptor = this.data.getType().getAttributeDescriptor(index);

        Object value = this.get(index);

        String profileName = descriptor.getDataProfileName();

        if (StringUtils.isBlank(profileName)) {

            return value;

        }

        DataProfile profile = DALLocator.getDataManager().getDataProfile(profileName);

        if (profile == null) {

            return value;

        }

        return profile.createData(value, descriptor.getTags());

    }

    @Override

    public Object getFromProfile(String name) {

        FeatureAttributeDescriptor descriptor = this.data.getType().getAttributeDescriptor(name);

        return this.getFromProfile(descriptor.getIndex());

    }

    private Object get(String name, Class theClass, int type) {

        Object value = this.get(name);

        if (theClass.isInstance(value)) {

            return value;

        }

        try {

            return this.getDataTypesManager().coerce(type, value);

        } catch (CoercionException e) {

            if (value == null) {

                return null;

            }

            throw new IllegalArgumentException(

                    "Can't convert to " + theClass.getName()

                    + " from '" + value.getClass().getName()

                    + "' with value '" + value.toString() + "'.");

        }

    }

    @Override

    public Object get(String name) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

            // buscamos en los extra cols

            if (hasExtraColumnValue(name)) {

                return getExtraColumnValue(name);

            }

            if (hasExtraValue(name)) {

                return getExtraValue(name);

            }

            // y si esta ahi return

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

        }

        return this.get(index);

    }

    @Override

    public boolean isNull(int index) {

        FeatureType type = this.data.getType();

        if (index < 0 || index >= type.size()) {

            throw new IllegalArgumentException("Attribute index '" + index + "' out of range (0 to " + this.data.getType().size() + ".");

        }

        FeatureAttributeDescriptor attribute = type.getAttributeDescriptor(index);

        if (!this.data.getType().hasEvaluators()) {

            return this.data.get(index) == null;

        }

        Evaluator eval = attribute.getEvaluator();

        if (eval == null) {

            return this.data.get(index) == null;

        }

        Object value = this.data.get(index);

        if (value != null) {

            return true;

        }

        try {

            value = eval.evaluate(this);

        } catch (EvaluatorException e) {

            throw new DataEvaluatorRuntimeException(e);

        }

        this.data.set(index, value);

        return value == null;

    }

    @Override

    public boolean isNull(String name) {

        int index = this.data.getType().getIndex(name);

        if (index < 0) {

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

        }

        return this.isNull(index);

    }

    public boolean has_key(String key) {

        Object x = this.getType().get(key);

        return x != null;

    }

    public List<String> keys() {

        List<String> ks = new ArrayList<>();

        for (FeatureAttributeDescriptor attr : this.getType()) {

            ks.add(attr.getName());

        }

        return ks;

    }

    public Iterator<String> iterkeys() {

        final Iterator it = this.getType().iterator();

        return new Iterator<String>() {

            @Override

            public boolean hasNext() {

                return it.hasNext();

            }

            @Override

            public String next() {

                return ((FeatureAttributeDescriptor) it.next()).getName();

            }

            @Override

            public void remove() {

                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

            }

        };

    }

    public Iterator iteritems() {

        final Iterator it = this.getType().iterator();

        return new Iterator<Map.Entry>() {

            @Override

            public boolean hasNext() {

                return it.hasNext();

            }

            @Override

            public Map.Entry next() {

                final String name = ((FeatureAttributeDescriptor) it.next()).getName();

                return new Map.Entry<String, Object>() {

                    @Override

                    public String getKey() {

                        return name;

                    }

                    @Override

                    public Object getValue() {

                        return get(name);

                    }

                    @Override

                    public Object setValue(Object value) {

                        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

                    }

                };

            }

            @Override

            public void remove() {

                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

            }

        };

    }

    @Override

    public Object get(int index) {

        FeatureType type = this.data.getType();

        if (index < 0 || index >= type.size()) {

            throw new IllegalArgumentException("Attribute index '" + index + "' out of range (0 to " + this.data.getType().size() + ".");

        }

        Object value = this.data.get(index);

        FeatureAttributeDescriptor attribute = type.getAttributeDescriptor(index);

        if (type.hasEvaluators()) {

            Evaluator eval = attribute.getEvaluator();

            if (eval != null) {

                if (value == null) { // Ya hemos calculado el campo ?

                    // FIXME: para comprobar si esta calculado usar un array especifico.

                    try {

                        value = eval.evaluate(this);

                    } catch (EvaluatorException e) {

                        throw new DataEvaluatorRuntimeException(e);

                    }

                    this.data.set(index, value);

                }

            }

        }

        value = get(attribute, value);

        return value;

    }

    private Object get(FeatureAttributeDescriptor featureAttributeDescriptor, Object value) {

        FeatureAttributeEmulator emulator = featureAttributeDescriptor.getFeatureAttributeEmulator();

        if (emulator != null) {

//            int index = featureAttributeDescriptor.getIndex();

//            value = this.data.get(index);

//            if( value==null ) {

            value = this.getExtraValue(featureAttributeDescriptor.getName());

            if (value==null) {

                value = emulator.get(this);

            }

//                this.data.set(index,value);

//            }

        } else {

            FeatureAttributeGetter getter = featureAttributeDescriptor.getFeatureAttributeGetter();

            if (getter != null) {

                value = getter.getter(value);

            }

        }

        value = coerce(featureAttributeDescriptor, value);

        return value;

    }

    private Object coerce(FeatureAttributeDescriptor attr, Object value) {

        if( value == null ) {

            return null;

        }

        DataType dataType = attr.getDataType();

        Class<? extends DataType> theClass = dataType.getDefaultClass();

        if (theClass != null && !theClass.isInstance(value)) {

            try {

                value = this.getDataTypesManager().coerce(dataType.getType(), value);

            } catch (CoercionException e) {

                throw new IllegalArgumentException(

                        "Can't convert to " + theClass.getSimpleName()

                        + " from '" + value==null? "NULL":value.getClass().getSimpleName()

                        + "' with value '" + Objects.toString(value) + "'.");

            }

        }

        if (attr.getType() == DataTypes.GEOMETRY) {

            if (value != null) {

                Geometry geom = (Geometry) value;

                if (geom.getProjection() == null) {

                    IProjection proj = ((DefaultFeatureAttributeDescriptor) attr).getSRS(this.storeRef);

                    geom.setProjection(proj);

                }

            }

        }

        return value;

    }

    @Override

    public byte[] getByteArray(String name) {

        return (byte[]) this.get(name);

    }

    @Override

    public byte[] getByteArray(int index) {

        return (byte[]) this.get(index);

    }

    @Override

    public Object[] getArray(String name) {

        return (Object[]) this.get(name);

    }

    @Override

    public Object[] getArray(int index) {

        return (Object[]) this.get(index);

    }

    @Override

    public boolean getBoolean(String name) {

        Boolean value = ((Boolean) this.get(name, Boolean.class, DataTypes.BOOLEAN));

        if (value == null) {

            return false;

        }

        return value;

    }

    @Override

    public boolean getBoolean(int index) {

        Boolean value = ((Boolean) this.get(index, Boolean.class, DataTypes.BOOLEAN));

        if (value == null) {

            return false;

        }

        return value;

    }

    @Override

    public byte getByte(String name) {

        Byte value = ((Byte) this.get(name, Byte.class, DataTypes.BYTE));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public byte getByte(int index) {

        Byte value = ((Byte) this.get(index, Byte.class, DataTypes.BYTE));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public java.sql.Date getDate(String name) {

        java.sql.Date value = ((java.sql.Date) this.get(name, java.sql.Date.class, DataTypes.DATE));

        return value;

    }

    @Override

    public java.sql.Date getDate(int index) {

        java.sql.Date value = ((java.sql.Date) this.get(index, java.sql.Date.class, DataTypes.DATE));

        return value;

    }

    @Override

    public java.sql.Time getTime(String name) {

        java.sql.Time value = ((java.sql.Time) this.get(name, java.sql.Time.class, DataTypes.TIME));

        return value;

    }

    @Override

    public java.sql.Time getTime(int index) {

        java.sql.Time value = ((java.sql.Time) this.get(index, java.sql.Time.class, DataTypes.TIME));

        return value;

    }

    @Override

    public java.sql.Timestamp getTimestamp(String name) {

        java.sql.Timestamp value = ((java.sql.Timestamp) this.get(name, java.sql.Timestamp.class, DataTypes.TIMESTAMP));

        return value;

    }

    @Override

    public java.sql.Timestamp getTimestamp(int index) {

        java.sql.Timestamp value = ((java.sql.Timestamp) this.get(index, java.sql.Timestamp.class, DataTypes.TIMESTAMP));

        return value;

    }

    @Override

    public double getDouble(String name) {

        Double value = ((Double) this.get(name, Double.class, DataTypes.DOUBLE));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public double getDouble(int index) {

        Double value = ((Double) this.get(index, Double.class, DataTypes.DOUBLE));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public BigDecimal getDecimal(String name) {

        BigDecimal value = ((BigDecimal) this.get(name, BigDecimal.class, DataTypes.DECIMAL));

        return value;

    }

    @Override

    public BigDecimal getDecimal(int index) {

        BigDecimal value = ((BigDecimal) this.get(index, BigDecimal.class, DataTypes.DECIMAL));

        return value;

    }

    @Override

    public Feature getFeature(String name) {

        return this.getFeature(this.data.getType().getIndex(name));

    }

    @Override

    public Feature getFeature(int index) {

        return (Feature) this.get(index);

    }

    @Override

    public float getFloat(String name) {

        Float value = ((Float) this.get(name, Float.class, DataTypes.FLOAT));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public float getFloat(int index) {

        Float value = ((Float) this.get(index, Float.class, DataTypes.FLOAT));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public Geometry getGeometry(String name) {

        return (Geometry) this.get(name, Geometry.class, DataTypes.GEOMETRY);

    }

    @Override

    public Geometry getGeometry(int index) {

        return (Geometry) this.get(index, Geometry.class, DataTypes.GEOMETRY);

    }

    @Override

    public int getInt(String name) {

        Integer value = ((Integer) this.get(name, Integer.class, DataTypes.INT));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public int getInt(int index) {

        Integer value = ((Integer) this.get(index, Integer.class, DataTypes.INT));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public long getLong(String name) {

        Long value = ((Long) this.get(name, Long.class, DataTypes.LONG));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public long getLong(int index) {

        Long value = ((Long) this.get(index, Long.class, DataTypes.LONG));

        if (value == null) {

            return 0;

        }

        return value;

    }

    @Override

    public String getString(String name) {

        return (String) this.get(name, String.class, DataTypes.STRING);

    }

    @Override

    public String getString(int index) {

        return (String) this.get(index, String.class, DataTypes.STRING);

    }

    @Override

    public Object getContextValue(String name) {

        name = name.toLowerCase();

        if (name.equals("store")) {

            return this.getStore();

        }

        if (name.equals("featuretype")) {

            return this.data.getType();

        }

        if (name.equals("feature")) {

            return this;

        }

        throw new IllegalArgumentException(name);

    }

    @Override

    public Iterator getDataNames() {

        class DataNamesIterator implements Iterator {

            Iterator attributeIteraror;

            DataNamesIterator(DefaultFeature feature) {

                this.attributeIteraror = feature.getType().iterator();

            }

            @Override

            public boolean hasNext() {

                return this.attributeIteraror.hasNext();

            }

            @Override

            public Object next() {

                return ((FeatureAttributeDescriptor) this.attributeIteraror

                        .next()).getName();

            }

            @Override

            public void remove() {

                throw new UnsupportedOperationException();

            }