Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * 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 2 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.tools.dynobject.impl;

import java.io.File;

import java.net.URI;

import java.net.URL;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.dynobject.exception.DynFieldIsNotAContainerException;

import org.gvsig.tools.dynobject.exception.DynFieldRequiredValueException;

import org.gvsig.tools.dynobject.exception.DynFieldValidateException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynObjectValidateException;

import org.gvsig.tools.exception.ListBaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("EqualsAndHashcode")

public class DefaultDynField implements DynField_v2 {

    public static final Logger log = LoggerFactory.getLogger(DefaultDynField.class);

    private String name;

    private String description;

    private ValueType valueType;

    private String subtype;

    private Object defaultValue;

    private int order;

    private boolean hidden;

    private String groupName;

    private DynObjectValueItem[] availableValues;

    private DynMethod availableValuesMethod = null;

    private Object minValue;

    private Object maxValue;

    private boolean mandatory;

    private boolean persistent;

    private String label = null;

    private boolean isReadOnly;

    private Tags tags = new DefaultTags();

    private ValueType itemsType;

    private boolean validateItems;

//        Para implementacion futura, como minimo para implementar

//        un copy entre dynobject y saber cuando parar.

//        Los valores deberan ser algo asi como:

//        - Identidad/Identity, 1:1 y se copian.

//        - Composicion/Composition, 1:N y se copian.

//        - Agregacion/Aggregate, 1:N, no se copian

//        - Colaboracion/Collaboration, 1:1, no se copian

//        Y solo tendra efecto/sentido cuando el field sea de tipo

//        DynObject, y tal vez lista de DynObject

    private int relationType;

    private DynMethod calculate = null;

    public DefaultDynField(String name, int dataType) {

        this(name, // field name

                dataType, // data type

                null, // default value

                true, // persistent

                false // mandatory

        );

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    protected DefaultDynField(String name, int dataType, Object defaultValue,

            boolean persistent, boolean mandatory) {

        DataTypesManager datamanager = ToolsLocator.getDataTypesManager();

        if (StringUtils.isBlank(name)) {

            throw new IllegalArgumentException("name can't be null");

        }

        this.name = name;

        this.valueType = new ValueType(dataType);

        this.subtype = this.getSubtype();

        this.defaultValue = defaultValue;

        this.persistent = persistent;

        this.mandatory = mandatory;

        this.groupName = null;

        this.order = 0;

        this.hidden = false;

        this.availableValues = null;

        this.itemsType = new ValueType(DataTypes.UNKNOWN);

        this.validateItems = false;

        this.relationType = RELATION_TYPE_NONE;

    }

    @Override

    public void copyFrom(DynField other) {

        this.name = other.getName();

        this.description = other.getDescription();

        this.subtype = other.getSubtype();

        this.defaultValue = other.getDefaultValue();

        this.order = other.getOder();

        this.hidden = other.isHidden();

        this.groupName = other.getGroup();

        this.minValue = other.getMinValue();

        this.maxValue = other.getMaxValue();

        this.mandatory = other.isMandatory();

        this.persistent = other.isMandatory();

        this.isReadOnly = other.isReadOnly();

        this.tags = new DefaultTags();

        if (other instanceof DynField_v2) {

            DynField_v2 other2 = (DynField_v2) other;

            this.tags.add(other2.getTags());

            this.label = other2.getLabel();

            this.validateItems = other2.getValidateElements();

            if (other2.isCalculated()) {

                this.setCalculateMethod(other2.getCalculateMethod());

            }

            if( other2.isAvailableValuesCalculated() ) {

                this.availableValuesMethod = other2.getAvailableValuesMethod();

            } else {

                this.availableValues = other.getAvailableValues().clone();

            }

            this.setType(other.getDataType());

            this.setClassOfValue(other2.getClassOfValue());

            this.setClassOfValue(other2.getDynClassOfValue());

            this.setTypeOfItems(other2.getTypeOfItems());

            this.setClassOfItems(other2.getClassOfItems());

            this.setClassOfItems(other2.getDynClassOfItems());

        }

    }

    protected ValueType getValueType() {

        return valueType;

    }

    @Override

    public DynField setCalculateMethod(DynMethod method) {

        this.calculate = method;

        this.persistent = false;

        return this;

    }

    public DynMethod getCalculateMethod() {

        return this.calculate;

    }

    @Override

    public boolean isCalculated() {

        return this.calculate != null;

    }

    @Override

    public Object getCalculatedValue(DynObject self) {

        try {

            return this.calculate.invoke(self, new Object[]{this});

        } catch (DynMethodException ex) {

            throw new RuntimeException(ex);

        }

    }

    public void check() throws ListBaseException {

    }

    @Override

    public String toString() {

        StringBuilder buffer = new StringBuilder();

        buffer.append("DynField").append("[").append(this.hashCode())

                .append("]").append("( ").append("name='").append(this.name)

                .append("', ").append("description='").append(this.description)

                .append("', ").append("type='").append(this.valueType)

                .append("', ").append("subType='").append(this.subtype)

                .append("', ").append("mandatory='").append(this.isMandatory())

                .append("', ").append("defaultValue='")

                .append(this.getDefaultValue()).append("', ")

                .append("minValue='").append(this.minValue).append("', ")

                .append("maxValue='").append(this.maxValue).append("', ")

                .append("persistent='").append(this.isPersistent())

                .append(" )");

        return buffer.toString();

    }

    @Override

    public String getName() {

        return name;

    }

    public DynField setName(String name) {

        if (StringUtils.isBlank(name)) {

            throw new IllegalArgumentException("name can't be null");

        }

        this.name = name;

        return this;

    }

    @Override

    public DynField setDescription(String description) {

        this.description = description;

        return this;

    }

    @Override

    public String getDescription() {

        return (description == null) ? getLabel() : description;

    }

    @Override

    public DynField setLabel(String label) {

        this.label = label;

        return this;

    }

    @Override

    public String getLabel() {

        return (label == null) ? getName() : label;

    }

    @Override

    public DynField setType(int dataType) {

        this.valueType.setType(dataType);

        return this;

    }

    @Override

    public DynField setType(DataType dataType) {

        this.valueType.setType(dataType);

        return this;

    }

    @Override

    public int getType() {

        return this.valueType.getType();

    }

    @Override

    public DataType getDataType() {

        return this.valueType.getDataType();

    }

    @Override

    public DynField setSubtype(String subtype) {

        this.subtype = subtype;

        return this;

    }

    @Override

    public String getSubtype() {

        return subtype;

    }

    @Override

    public DynField setDefaultDynValue(Object defaultValue) {

        this.defaultValue = defaultValue;

        return this;

    }

    @Override

    public Object getDefaultValue() {

        return defaultValue;

    }

    @Override

    public boolean isAvailableValuesCalculated() {

        return this.availableValuesMethod != null;

    }

    @Override

    public DynField setAvailableValues(DynObjectValueItem[] availableValues) {

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

            this.availableValues = null;

        } else {

            this.availableValues = availableValues;

        }

        return this;

    }

    @Override

    public DynField setAvailableValues(List availableValues) {

        if (availableValues == null) {

            this.availableValues = null;

        } else if (availableValues.isEmpty()) {

            this.availableValues = null;

        } else {

            this.availableValues = (DynObjectValueItem[]) availableValues

                    .toArray(new DynObjectValueItem[availableValues.size()]);

        }

        return this;

    }

    @Override

    public DynField setAvailableValues(DynMethod computeAvailableValues) {

        this.availableValuesMethod = computeAvailableValues;

        return this;

    }

    @Override

    public DynMethod getAvailableValuesMethod() {

        return this.availableValuesMethod;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues() {

        return this.getAvailableValues(null);

    }

    @Override

    public DynObjectValueItem[] getAvailableValues(DynObject self) {

        if (this.availableValuesMethod != null) {

            DynObjectValueItem[] values;

            try {

                values = (DynObjectValueItem[]) this.availableValuesMethod.invoke(self, new Object[]{this});

            } catch (DynMethodException ex) {

                return this.availableValues;

            }

            if (values != null) {

                return values;

            }

        }

        return this.availableValues;

    }

    @Override

    public DynField setMinValue(Object minValue) {

        try {

            this.minValue = this.coerce(minValue);

        } catch (CoercionException e) {

            throw new IllegalArgumentException();

        }

        return this;

    }

    @Override

    public Object getMinValue() {

        return minValue;

    }

    @Override

    public DynField setMaxValue(Object maxValue) {

        try {

            this.maxValue = this.coerce(maxValue);

        } catch (CoercionException e) {

            throw new IllegalArgumentException(e);

        }

        return this;

    }

    @Override

    public Object getMaxValue() {

        return maxValue;

    }

    @Override

    public boolean isMandatory() {

        return this.mandatory;

    }

    @Override

    public boolean isPersistent() {

        if (this.isCalculated()) {

            return false;

        }

        return this.persistent;

    }

    @Override

    public DynField setMandatory(boolean mandatory) {

        this.mandatory = mandatory;

        return this;

    }

    @Override

    public DynField setPersistent(boolean persistent) {

        if (this.isCalculated()) {

            persistent = false;

        }

        this.persistent = persistent;

        return this;

    }

    @Override

    public DynField setTheTypeOfAvailableValues(int type) {

        return this; // FIXME: this method is @deprecated

    }

    @Override

    public int getTheTypeOfAvailableValues() {

        return 1; // FIXME: this method is @deprecated

    }

    /**

     *

     * @param obj

     * @return

     */

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj instanceof DynField) {

            // FIXME: No esta claro que esto sea correcto.

            return name.equals(((DynField) obj).getName());

        }

        return false;

    }

    @Override

    public Class getClassOfValue() {

        return this.valueType.getClassOfValue();

    }

    @Override

    public DynField setClassOfValue(Class theClass) {

        this.valueType.setClassOfValue(theClass);

        return this;

    }

    @Override

    public DynField setClassOfValue(String theClassName) {

        this.valueType.setClassOfValue(theClassName);

        return this;

    }

    @Override

    public boolean isContainer() {

        if (valueType.getDataType() == null) {

            return false;

        }

        return valueType.getDataType().isContainer();

    }

    @Override

    public void validate(Object value) throws DynFieldValidateException {

        Comparable v;

        if (value == null) {

            if (this.mandatory) {

                throw new DynFieldRequiredValueException(this, value);

            }

            return;

        }

        switch (this.valueType.getType()) {

            case DataTypes.BOOLEAN:

                if (!(value instanceof Boolean)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.DOUBLE:

                if (!(value instanceof Double)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.FLOAT:

                if (!(value instanceof Float)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.BYTE:

                if (!(value instanceof Byte)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.INT:

                if (!(value instanceof Integer)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.LONG:

                if (!(value instanceof Long)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.STRING:

                if (!(value instanceof String)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.CHAR:

                if (!(value instanceof String)) {

                    throw new DynFieldValidateException(value, this);

                }

                if (((String) value).length() > 1) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.DATE:

                if (!(value instanceof Date)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.TIMESTAMP:

                if (!(value instanceof Date)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.TIME:

                if (!(value instanceof Date)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.FILE:

                if (!(value instanceof File)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.FOLDER:

                if (!(value instanceof File)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.URI:

                if (!(value instanceof URI)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.URL:

                if (!(value instanceof URL)) {

                    throw new DynFieldValidateException(value, this);

                }

                break;

            case DataTypes.ARRAY:

                // TODO: falta verificar que es un array del tipo que toca.

                break;

            case DataTypes.OBJECT:

                if (this.valueType.getClassOfValue() != null) {

                    if (!this.valueType.getClassOfValue().isInstance(value)) {

                        throw new DynFieldValidateException(value, this);

                    }

                }

                break;

            case DataTypes.MAP:

                if (!(value instanceof Map)) {

                    throw new DynFieldValidateException(value, this);

                }

                validateCollection(value);

                break;

            case DataTypes.SET:

                if (!(value instanceof Set)) {

                    throw new DynFieldValidateException(value, this);

                }

                validateCollection(value);

                break;

            case DataTypes.LIST:

                if (!(value instanceof List)) {

                    throw new DynFieldValidateException(value, this);

                }

                validateCollection(value);

                break;

            case DataTypes.DYNOBJECT:

                if (!(value instanceof DynObject)) {

                    throw new DynFieldValidateException(value, this);

                }

                if (!this.getDynClassOfValue().isInstance((DynObject) value)) {

                    throw new DynFieldValidateException(value, this);

                }

                try {

                    this.getDynClassOfValue().validate((DynObject) value);

                } catch (DynObjectValidateException e) {

                    throw new DynFieldValidateException(value, this, e);

                }

                break;

            default:

                if (this.valueType.getDataType().isObject()) {

                    if (this.valueType.getClassOfValue() != null) {

                        if (!this.valueType.getClassOfValue().isInstance(value)) {

                            throw new DynFieldValidateException(value, this);

                        }

                    }

                }

        }

        if (this.getAvailableValues() != null) {

            if (!(value instanceof Comparable)) {

                throw new DynFieldValidateException(value, this);

            }

            v = (Comparable) value;

            boolean ok = false;

            for (DynObjectValueItem availableValue : this.availableValues) {

                if (v.compareTo(availableValue.getValue()) == 0) {

                    ok = true;

                    break;

                }

            }

            if (!ok) {

                throw new DynFieldValidateException(value, this);

            }

        } else if (this.getMaxValue() != null && this.getMinValue() != null) {

            if (!(value instanceof Comparable)) {

                throw new DynFieldValidateException(value, this);

            }

            v = (Comparable) value;

            if (v.compareTo(this.minValue) < 0

                    || v.compareTo(this.maxValue) > 0) {

                throw new DynFieldValidateException(value, this);

            }

        }

    }

    private void validateCollection(Object value) throws ValidateItemException {

        if (this.validateItems) {

            DynStruct dynClass = this.itemsType.getDynClassOfValue();

            if (dynClass != null) {

                int index = 0;

                Iterator it = ((Collection) value).iterator();

                while (it.hasNext()) {

                    try {

                        dynClass.validate((DynObject) it.next());

                        index++;

                    } catch (DynObjectValidateException ex) {

                        throw new ValidateItemException(ex, index);

                    }

                }

            }

        }

    }

    private static class ValidateItemException extends DynFieldValidateException {

        private static final long serialVersionUID = 9011437364983996567L;

        ValidateItemException(Throwable cause, int index) {

            super(

                    "Can't validate item %(index) of the collection.",

                    cause,

                    "_Cant_validate_item_%(index)_of_the_collection",

                    serialVersionUID

            );

            setValue("index", index);

        }

    }

    @Override

    public Object coerce(Object value) throws CoercionException {

        if (value == null) {

            return value; // O debe devolver this.defaultValue

        }

        try {

            return this.valueType.getDataType().coerce(value);

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public String getGroup() {

        return this.groupName;

    }

    @Override

    public DynField setGroup(String groupName) {

        this.groupName = groupName;

        return this;

    }

    @Override

    public int getOder() {

        return this.order;

    }

    @Override

    public DynField setOrder(int order) {

        this.order = order;

        return this;

    }

    @Override

    public boolean isHidden() {

        return this.hidden;

    }

    @Override

    public DynField setHidden(boolean hidden) {

        this.hidden = hidden;

        return this;

    }

    @Override

    public boolean isReadOnly() {

        return this.isReadOnly;

    }

    @Override

    public DynField setReadOnly(boolean isReadOnly) {

        this.isReadOnly = isReadOnly;

        return this;

    }

    @Override

    public DynField setDefaultFieldValue(Object defaultValue) {

        try {

            this.defaultValue = this.coerce(defaultValue);

        } catch (CoercionException e) {

            throw new IllegalArgumentException(e);

        }

        return this;

    }

    @Override

    public Tags getTags() {

        return tags;

    }

    @Override

    public String getClassNameOfValue() {

        return this.valueType.getClassNameOfValue();

    }

    @Override

    public DynField setClassOfValue(DynStruct dynStruct) {

        this.valueType.setClassOfValue(dynStruct);

        return this;

    }

    @Override

    public DynStruct getDynClassOfValue() {

        return this.valueType.getDynClassOfValue();

    }

    @Override

    public int getRelationType() {

        return this.relationType;

    }

    @Override

    public DynField setRelationType(int relationType) {

        this.relationType = relationType;

        return this;

    }

    @Override

    public DynField setElementsType(int type) {

        this.setTypeOfItems(type);

        return this;

    }

    @Override

    public DynField setElementsType(DynStruct type) {

        this.setClassOfItems(type);

        return this;

    }

    @Override

    public DynField getElementsType() {

        throw new UnsupportedOperationException("This operation is not suported nevermore.");

    }

    @Override

    public DynField setClassOfItems(DynStruct dynStrct) {

        if (dynStrct!=null && !this.isContainer()) {

            throw new IllegalStateException("Can't assign classOfItems in non container.");

        }

        this.itemsType.setClassOfValue(dynStrct);

        return this;

    }

    @Override

    public DynField setClassOfItems(String theClassNameOfValue) {

        if (theClassNameOfValue!=null && !this.isContainer()) {

            throw new IllegalStateException("Can't assign classOfItems in non container.");

        }

        this.itemsType.setClassOfValue(theClassNameOfValue);

        return this;

    }

    @Override

    public String getClassNameOfItems() {

        if( this.itemsType==null || 

                this.itemsType.getClassNameOfValue()==null ) {

            return null;

        }

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't get classNameOfItems in non container.");

        }

        return this.itemsType.getClassNameOfValue();

    }

    @Override

    public DynStruct getDynClassOfItems() {

        if( this.itemsType==null || 

                this.itemsType.getDynClassOfValue()==null ) {

            return null;

        }

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't get dynClassOfItems in non container.");

        }

        return this.itemsType.getDynClassOfValue();

    }

    @Override

    public DynField setClassOfItems(Class theClass)

            throws DynFieldIsNotAContainerException {

        if (theClass!=null && !this.isContainer()) {

            throw new IllegalStateException("Can't assign classNameOfItems in non container.");

        }

        this.itemsType.setClassOfValue(theClass);

        return this;

    }

    @Override

    public Class getClassOfItems() {

        if( this.itemsType==null || 

                this.itemsType.getClassOfValue()==null ) {

            return null;

        }

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't get classOfItems in non container.");

        }

        return this.itemsType.getClassOfValue();

    }

    @Override

    public DynField setTypeOfItems(int type) {

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't assign typeOfItems in non container.");

        }

        this.itemsType.setType(type);

        return this;

    }

    @Override

    public int getTypeOfItems() {

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't get typeOfItems in non container.");

        }

        return this.itemsType.getType();

    }

    @Override

    public DynField setValidateElements(boolean validate) {

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't assign validateElements in non container.");

        }

        this.validateItems = validate;

        return this;

    }

    @Override

    public boolean getValidateElements() {

        if (!this.isContainer()) {

            throw new IllegalStateException("Can't get validateElements in non container.");

        }

        return this.validateItems;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultDynField other = (DefaultDynField) super.clone();

        other.tags = (Tags) this.tags.clone();

        other.valueType = (ValueType) this.valueType.clone();

        other.itemsType = (ValueType) this.itemsType.clone();

        if( this.availableValues==null ) {

            other.availableValues = null;

        } else {

            other.availableValues = this.availableValues.clone();

        }

        other.calculate = (DynMethod) this.calculate;

        return other;

    }

}