Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.file.dbf;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.vectorial.AbstractFeatureCollection;

import org.gvsig.data.vectorial.FeatureManager;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureCollection;

import org.gvsig.data.vectorial.IFeatureID;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

import org.gvsig.data.vectorial.expressionevaluator.FeatureComparator;

import org.gvsig.util.observer.Observable;

//FIXME: OJO Excepciones

public class DBFFeatureCollectionWithFeatureID extends AbstractFeatureCollection {

        protected Observable observable = new Observable();

        protected Collection featureIDs;//<IFeatureID>

        protected IFeatureType featureType;

        public DBFFeatureCollectionWithFeatureID(FeatureManager fm,DBFStore store,IFeatureType type, String filter,String Order) throws ReadException {

                this.featureType=type;

                intilizeFeatureIDs(fm, store, filter, Order);

        }

        protected void intilizeFeatureIDs(FeatureManager fm,DBFStore store, String filter,String order) throws ReadException {

                try{

                if (order == null){

                        if (filter == null){

                                featureIDs = new ArrayList(); // Si queremos optimizar deberiamos inicializar

                                // el tama?o

                        } else {

                                featureIDs = new ArrayList();

                        }

                } else {

                        Comparator comparator = new FeatureComparator(this.featureType,order);

                        featureIDs = new TreeSet(comparator);

                }

                IFeatureCollection coll = new DBFFeatureCollection(fm,store,this.featureType,filter);

                Iterator iter = coll.iterator();

                while (iter.hasNext()){

                        IFeature feature =(IFeature)iter.next();

                        featureIDs.add(feature.getID());

                }

                }catch (Exception e) {

                        throw new ReadException("DBFFeatureCollection",e);

                }

        }

        public int size() {

                return featureIDs.size();

        }

        public boolean isEmpty() {

                return featureIDs.isEmpty();

        }

        public boolean contains(Object o) {

                if (o instanceof IFeature){

                        featureIDs.contains(((IFeature)o).getID());

                }

                return featureIDs.contains(o);

        }

        public Iterator iterator() {

                DBFFIDIterator dbfIter=new DBFFIDIterator(featureIDs.iterator());

                return dbfIter;

        }

        public Object[] toArray() {

                ArrayList features= new ArrayList();

                Iterator iterator= this.iterator();

                while(iterator.hasNext()){

                        IFeature feature=(IFeature)iterator.next();

                        features.add(feature);

                }

                return features.toArray();

        }

        public Object[] toArray(Object[] a) {

                ArrayList features= new ArrayList();

                Iterator iterator= this.iterator();

                while(iterator.hasNext()){

                        IFeature feature=(IFeature)iterator.next();

                        features.add(feature);

                }

                return features.toArray(a);

        }

        public boolean add(Object o) {

                throw new UnsupportedOperationException();

        }

        public boolean remove(Object o) {

                throw new UnsupportedOperationException();

        }

        public boolean containsAll(Collection c) {

                Iterator iter = c.iterator();

                while (iter.hasNext()){

                        if (!this.contains(iter.next())){

                                return false;

                        }

                }

                return true;

        }

        public boolean addAll(Collection c) {

                throw new UnsupportedOperationException();

        }

        public boolean removeAll(Collection c) {

                throw new UnsupportedOperationException();

        }

        public boolean retainAll(Collection c) {

                throw new UnsupportedOperationException();

        }

        public void clear() {

                throw new UnsupportedOperationException();

        }

        private class DBFFIDIterator implements Iterator{

                private Iterator iter;

                public DBFFIDIterator(Iterator iter){

                        this.iter=iter;

                }

                public boolean hasNext() {

                        return iter.hasNext();

                }

                public Object next() {

                        IFeatureID fid= (IFeatureID)iter.next();

                        IFeature feature;

                        try {

                                feature = fid.getFeature(featureType);

                        } catch (ReadException e) {

                                throw new RuntimeException(e);

                        }

                        return feature;

                }

                public void remove() {

                        throw new UnsupportedOperationException();

                }

        }

        public void dispose() {

                observable.deleteObservers();

                this.observable = null;

                this.featureIDs.clear();

                this.featureIDs= null;

                this.featureType = null;

        }

}