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

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

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

import org.gvsig.tools.exception.ListBaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultDynField implements DynField_v2 {

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

    private String name;

    private String description;

    private ValueType type;

    private String subtype;

    private Object defaultValue;

    private int order;

    private boolean hidden;

    private String groupName;

    private DynObjectValueItem[] availableValues;

    private Object minValue;

    private Object maxValue;

    private boolean mandatory;

    private boolean persistent;

    private String label = null;

    private boolean validateElements;

    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:

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

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

//        - Colaboracion, 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;

    public DefaultDynField(String name, int dataType) {

        this(name, // field name

                dataType, // data type

                null, // default value

                true, // persistent

                false // mandatory

        );

    }

    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.type = new ValueType(dataType);

        this.subtype = this.getSubtype();

        this.defaultValue = defaultValue;

        this.persistent = persistent;

        this.mandatory = mandatory;

        this.validateElements = false;

        this.groupName = null;

        this.order = 0;

        this.hidden = false;

        this.availableValues = null;

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

        this.validateItems = false;

    }

    protected ValueType getValueType() {

        return type;

    }

    public void check() throws ListBaseException {

    }

    public String toString() {

        StringBuffer buffer = new StringBuffer();

        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.type)

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

    }

    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;

    }

    public DynField setDescription(String description) {

        this.description = description;

        return this;

    }

    public String getDescription() {

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

    }

    public DynField setLabel(String label) {

        this.label = label;

        return this;

    }

    public String getLabel() {

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

    }

    public DynField setType(int dataType) {

        this.type.setType(dataType);

        return this;

    }

    public DynField setType(DataType dataType) {

        this.type.setType(dataType);

        return this;

    }

    public int getType() {

        return this.type.getType();

    }

    public DataType getDataType() {

        return this.type.getDataType();

    }

    public DynField setSubtype(String subtype) {

        this.subtype = subtype;

        return this;

    }

    public String getSubtype() {

        return subtype;

    }

    public DynField setDefaultDynValue(Object defaultValue) {

        this.defaultValue = defaultValue;

        return this;

    }

    public Object getDefaultValue() {

        return defaultValue;

    }

    public DynField setAvailableValues(DynObjectValueItem[] availableValues) {

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

            this.availableValues = null;

        } else {

            this.availableValues = availableValues;

        }

        return this;

    }

    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;

    }

    public DynObjectValueItem[] getAvailableValues() {

        return availableValues;

    }

    public DynField setMinValue(Object minValue) {

        try {

            this.minValue = this.coerce(minValue);

        } catch (CoercionException e) {

            IllegalArgumentException ex = new IllegalArgumentException(e.getLocalizedMessage());

            ex.initCause(e);

            throw ex;

        }

        return this;

    }

    public Object getMinValue() {

        return minValue;

    }

    public DynField setMaxValue(Object maxValue) {

        try {

            this.maxValue = this.coerce(maxValue);

        } catch (CoercionException e) {

            IllegalArgumentException ex = new IllegalArgumentException(e.getLocalizedMessage());

            ex.initCause(e);

            throw ex;

        }

        return this;

    }

    public Object getMaxValue() {

        return maxValue;

    }

    public boolean isMandatory() {

        return this.mandatory;

    }

    public boolean isPersistent() {

        return this.persistent;

    }

    public DynField setMandatory(boolean mandatory) {

        this.mandatory = mandatory;

        return this;

    }

    public DynField setPersistent(boolean persistent) {

        this.persistent = persistent;

        return this;

    }

    public DynField setTheTypeOfAvailableValues(int type) {

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

    }

    public int getTheTypeOfAvailableValues() {

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

    }

    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;

    }

    public Class getClassOfValue() {

        return this.type.getClassOfValue();

    }

    public DynField setClassOfValue(Class theClass) {

        this.type.setClassOfValue(theClass);

        return this;

    }

    public DynField setClassOfValue(String theClassName) {

        this.type.setClassOfValue(theClassName);

        return this;

    }

    public boolean isContainer() {

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

            return false;

        }

        return type.getDataType().isContainer();

    }

    public void validate(Object value) throws DynFieldValidateException {

        Comparable v;

        if ( value == null ) {

            if ( this.mandatory ) {

                throw new DynFieldRequiredValueException(this, value);

            }

            return;

        }

        switch (this.type.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.type.getClassOfValue() != null ) {

                if ( !this.type.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.type.getDataType().isObject() ) {

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

                    if ( !this.type.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 ( int i = 0; i < this.availableValues.length; i++ ) {

                if ( v.compareTo(this.availableValues[i].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", new Integer(index));

        }

    }

    public Object coerce(Object value) throws CoercionException {

        if ( value == null ) {

            return value; // O debe devolver this.defaultValue

        }

        try {

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

        } catch(Exception ex){

            throw new RuntimeException(ex);

        }

    }

    public String getGroup() {

        return this.groupName;

    }

    public DynField setGroup(String groupName) {

        this.groupName = groupName;

        return this;

    }

    public int getOder() {

        return this.order;

    }

    public DynField setOrder(int order) {

        this.order = order;

        return this;

    }

    public boolean isHidden() {

        return this.hidden;

    }

    public DynField setHidden(boolean hidden) {

        this.hidden = hidden;

        return this;

    }

    public boolean isReadOnly() {

        return this.isReadOnly;

    }

    public DynField setReadOnly(boolean isReadOnly) {

        this.isReadOnly = isReadOnly;

        return this;

    }

    public DynField setDefaultFieldValue(Object defaultValue) {

        try {

            this.defaultValue = this.coerce(defaultValue);

        } catch (CoercionException e) {

            IllegalArgumentException ex = new IllegalArgumentException(e.getLocalizedMessage());

            ex.initCause(e);

            throw ex;

        }

        return this;

    }

    public Tags getTags() {

        return tags;

    }

    public String getClassNameOfValue() {

        return this.type.getClassNameOfValue();

    }

    public DynField setClassOfValue(DynStruct dynStruct) {

        this.type.setClassOfValue(dynStruct);

        return this;

    }

    public DynStruct getDynClassOfValue() {

        return this.type.getDynClassOfValue();

    }

    public int getRelationType() {

        return this.relationType;

    }

    public DynField setRelationType(int relationType) {

        this.relationType = relationType;

        return this;

    }

    public DynField setElementsType(int type) {

        this.setTypeOfItems(type);

        return this;

    }

    public DynField setElementsType(DynStruct type) {

        this.setClassOfItems(type);

        return this;

    }

    public DynField getElementsType() {

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

    }

    public DynField setClassOfItems(DynStruct dynStrct) {

        if ( !this.isContainer() ) {

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

        }

        this.itemsType.setClassOfValue(dynStrct);

        return this;

    }

    public DynField setClassOfItems(String theClassNameOfValue) {

        if ( !this.isContainer() ) {

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

        }

        this.itemsType.setClassOfValue(theClassNameOfValue);

        return this;

    }

    public String getClassNameOfItems() {

        if ( !this.isContainer() ) {

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

        }

        return this.itemsType.getClassNameOfValue();

    }

    public DynStruct getDynClassOfItems() {

        if ( !this.isContainer() ) {

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

        }

        return this.itemsType.getDynClassOfValue();

    }

    public DynField setClassOfItems(Class theClass)

            throws DynFieldIsNotAContainerException {

        if ( !this.isContainer() ) {

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

        }

        this.itemsType.setClassOfValue(theClass);

        return this;

    }

    public Class getClassOfItems() {

        if ( !this.isContainer() ) {

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

        }

        return this.itemsType.getClassOfValue();

    }

    public DynField setTypeOfItems(int type) {

        if ( !this.isContainer() ) {

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

        }

        this.itemsType.setType(type);

        return this;

    }

    public int getTypeOfItems() {

        if ( !this.isContainer() ) {

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

        }

        return this.itemsType.getType();

    }

    public DynField setValidateElements(boolean validate) {

        if ( !this.isContainer() ) {

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

        }

        this.validateItems = validate;

        return this;

    }

    public boolean getValidateElements() {

        if ( !this.isContainer() ) {

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

        }

        return this.validateItems;

    }

}