| gvSIG desktop 1

package org.gvsig.fmap.data.feature;

import java.lang.ref.WeakReference;

import java.text.DateFormat;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.InitializeException;

public class DefaultFeatureType extends ArrayList implements FeatureType{

        /**

         *

         */

        private static final long serialVersionUID = 5120922022663837016L;

        protected List featureRules=new ArrayList();//<FeatureRule>

        private String geometryColumn;

        private List allSRS;

        private String defaultSRS;

        private int[] geometryTypes = new int[0];

        private DateFormat dateFormat=DateFormat.getDateInstance();

        private String[] fieldsId;

        private int count=0;

        private WeakReference originalFeatureType=null;

        public DefaultFeatureType(){

        }

        public void addRule(FeatureRule rule) {

                featureRules.add(rule);

        }

        public void clearRules() {

                featureRules.clear();

        }

        public void validateFeatureEnd(Feature feature, FeatureStore featureStore) {

                Iterator rulesIterator=featureRules.iterator();

                FeatureRule rule;

                while(rulesIterator.hasNext()){

                        rule = (FeatureRule)rulesIterator.next();

                        if (rule.checkAtEnd()){

                                rule.validate(feature,featureStore);

                        }

                }

        }

        public void validateFeatureModifiction(Feature feature, FeatureStore featureStore) {

                Iterator rulesIterator=featureRules.iterator();

                FeatureRule rule;

                while(rulesIterator.hasNext()){

                        rule = (FeatureRule)rulesIterator.next();

                        if (rule.checkAtModification()){

                                rule.validate(feature,featureStore);

                        }

                }

        }

        public void validateFeature(Feature feature, FeatureStore featureStore) {

                Iterator rulesIterator=featureRules.iterator();

                FeatureRule rule;

                while(rulesIterator.hasNext()){

                        rule = (FeatureRule)rulesIterator.next();

                        rule.validate(feature,featureStore);

                }

        }

        public void setDefaultGeometry(String name) {

                this.geometryColumn=name;

        }

        public String getDefaultGeometry() {

                return geometryColumn;

        }

        public Feature create(FeatureStore store) throws InitializeException {

                return store.createFeature(this, false);

        }

        public List getAllSRS() {

                return allSRS;

        }

        public String getDefaultSRS() {

                return defaultSRS;

        }

        public int[] getGeometryTypes() {

                return geometryTypes;

        }

        public void setAllSRS(List allSRS) {

                this.allSRS = allSRS;

        }

        public void setDefaultSRS(String defaultSRS) {

                this.defaultSRS = defaultSRS;

        }

        public DateFormat getDateFormat() {

                return dateFormat;

        }

        public void setDateFormat(DateFormat dateFormat) {

                this.dateFormat=dateFormat;

        }

        public void setGeometryTypes(int[] geometryTypes) {

                this.geometryTypes=geometryTypes;

        }

        public String[] getFieldsId() {

                return fieldsId;

        }

        public String[] getFields() {

                Iterator iterator=this.iterator();

                ArrayList names=new ArrayList();

                while (iterator.hasNext()) {

            FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator.next();

            names.add(fad.getName());

        }

                return (String[])names.toArray(new String[0]);

        }

        public void setFieldsId(String[] fieldsId) throws DataException {

                this.fieldsId = fieldsId;

                if (fieldsId != null) {

                        AttributeDescriptor attr = null;

                        int index = -1;

                        for (int i = 0; i < fieldsId.length; i++) {

                                index = this.getFieldIndex(fieldsId[i]);

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

                                        attr = (AttributeDescriptor) this.get(index);

                                        attr.loading();

                                        attr.setPrimaryKey(true);

                                        attr.stopLoading();

                                } else {

                                        throw new DataException("Field '" +fieldsId[i] + "' not found");

                                }

                        }

                }

        }

        /**

         * 

         * Return index of the value of the attribute 'name' in the feature values

         * list

         * 

         */

        public int getFieldIndex(String name) {

                int i;

                for (i=0;i<this.size();i++){

                        AttributeDescriptor attr=((AttributeDescriptor)this.get(i));

                        if (attr.getName().equals(name)) {

                                return attr.originalPosition();

                        }

                }

                return -1;

        }

        /**

         * Get the possition of attribute 'name' in the FeatureType at this moment

         */

        public int getCurrentIndex(String name) {

                int i;

                for (i = 0; i < this.size(); i++) {

                        AttributeDescriptor attr = ((AttributeDescriptor) this.get(i));

                        if (attr.getName().equals(name)) {

                                return i;

                        }

                }

                return -1;

        }

        public void add(int arg0, Object arg1) {

                throw new RuntimeException("Not supported!");

        }

        public boolean add(Object arg0) {

                ((AttributeDescriptor)arg0).setOrdinal(count);

                ((AttributeDescriptor) arg0).setFeatureType(this);

                count++;

                return super.add(arg0);

        }

        protected boolean addWithoutOrdinal(Object arg0) {

                ((AttributeDescriptor) arg0).setFeatureType(this);

                int max=((FeatureAttributeDescriptor)arg0).ordinal();

                if (count<=max){

                        count=max+1;

                }

                return super.add(arg0);

        }

        protected void fillFeatureType(DefaultFeatureType fType) {

                if (this.allSRS != null){

                        fType.allSRS = new ArrayList();

                        fType.allSRS.addAll(this.allSRS);

                }

                fType.dateFormat = this.dateFormat;

                fType.defaultSRS = this.defaultSRS;

                fType.featureRules.addAll(this.featureRules);

                if (this.fieldsId != null){

                        fType.fieldsId = new String[this.fieldsId.length];

                        System.arraycopy(this.fieldsId, 0, fType.fieldsId, 0,

                                        this.fieldsId.length);

                }

                fType.geometryColumn = this.geometryColumn;

                if (this.geometryTypes != null){

                        fType.geometryTypes = new int[this.geometryTypes.length];

                        System.arraycopy(this.geometryTypes, 0, fType.geometryTypes, 0,

                                        this.geometryTypes.length);

                }

                Iterator iter = this.iterator();

                while (iter.hasNext()){

                        fType.addWithoutOrdinal(((FeatureAttributeDescriptor) iter.next())

                                        .cloneAttribute());

                }

                fType.count = this.count;

        }

        public FeatureType cloneFeatureType() {

                DefaultFeatureType newFType = (DefaultFeatureType) this

                                .newFeatureType();

                newFType.setWeakReferenceOriginal(this);

                this.fillFeatureType(newFType);

                return newFType;

        }

        protected FeatureType newFeatureType(){

                return new DefaultFeatureType();

        }

        public FeatureAttributeDescriptor get(String name){

                return (FeatureAttributeDescriptor) this

                                .get(this.getCurrentIndex(name));

        }

        protected int getCount() {

                return count;

        }

        public void clear(){

                super.clear();

                this.count=0;

        }

        public FeatureAttributeDescriptor getByOrder(int i) {

                Iterator iterator=this.iterator();

                while (iterator.hasNext()) {

                        FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator.next();

                        if (i==fad.ordinal()){

                                return fad;

                        }

                }

                return null;

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.data.feature.FeatureType#createNewAttributeDescriptor()

         */

        public FeatureAttributeDescriptor createNewAttributeDescriptor() {

                return new AttributeDescriptor(this,true);

        }

        public FeatureAttributeDescriptor createAttributeDescriptor() {

                return new AttributeDescriptor(this,false);

        }

        public FeatureType getSubFeatureType(String[] fields) throws DataException {

                DefaultFeatureType featureType=(DefaultFeatureType)this.cloneFeatureType();

                if (fields != null) {

                        ArrayList toRemove = new ArrayList();

                        Iterator iter = this.iterator();

                        int index = -1;

                        int i = 0;

                        String name;

                        boolean found;

                        for (i = 0; i < fields.length; i++) {

                                index = this.getFieldIndex(fields[i]);

                                if (index < 0) {

                                        throw new DataException("Field '" + fields[i]

                                                        + "' not found");

                                }

                        }

                        while (iter.hasNext()) {

                                name = ((AttributeDescriptor) iter.next()).getName();

                                found = false;

                                for (i = 0; i < fields.length; i++) {

                                        if (name.equals(fields[i])) {

                                                found = true;

                                                break;

                                        }

                                }

                                if (!found) {

                                        index = this.getFieldIndex(name);

                                        toRemove.add(new Integer(index));

                                }

                        }

                        for (i = toRemove.size() - 1; i >= 0; i--) {

                                featureType.remove(((Integer) toRemove.get(i)).intValue());

                        }

                }

                return featureType;

        }

        protected void setWeakReferenceOriginal(DefaultFeatureType type) {

                originalFeatureType = new WeakReference(type);

        }

        public boolean isSubtypeOf(FeatureType featureType) {

                if (featureType.equals(this)){

                        return true;

                }

                if (this.originalFeatureType == null){

                        return false;

                }

                FeatureType myOriginal = (FeatureType) this.originalFeatureType.get();

                if (myOriginal == null){

                        return false;

                }

                return myOriginal.equals(featureType);

        }

}