| gvSIG desktop 1

package org.gvsig.data.datastores.vectorial.db.jdbc;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.TreeSet;

import org.gvsig.data.exception.ReadException;

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.expansionadapter.FeatureManager;

import org.gvsig.data.vectorial.filter.FeatureFilterParser;

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

public abstract class AbstractJDBCDataFeatureCollectionWithFeatureID extends

                AbstractJDBCDataFeatureCollection {

        protected JDBCStore store;

        protected Collection featureIDs;

        protected IFeatureType featureType;

        protected abstract IFeatureCollection newBaseDataFeatureCollection(JDBCStore store,IFeatureType featureType,String filter,String order);

        protected void init(FeatureManager fm, JDBCStore store, IFeatureType type, String filter, String order) throws ReadException {

                this.store=store;

                this.featureType= type;

                FeatureFilterParser parser = null;

                IFeature feature;

                Collection tmpFeatures;

                if (order == null){

                        if (filter == null){

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

                                // el tama?o

                        } else {

                                tmpFeatures = new ArrayList();

                        }

                } else {

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

                        tmpFeatures = new TreeSet(comparator);

                }

                if (filter != null && filter != ""){

                        parser = new FeatureFilterParser(filter,featureType);

                }

                for (int i=0;i<fm.getNum();i++){

                        feature = fm.getFeature(i);

                        if (fm.isDeleted(feature)){

                                continue;

                        }

                        if (parser == null || parser.match(feature)){

                                if (order != null){

                                        tmpFeatures.add(feature);

                                } else {

                                        tmpFeatures.add(feature.getID());

                                }

                        }

                }

                IFeatureCollection coll = this.newBaseDataFeatureCollection(store, featureType, filter, order);

                Iterator iter = coll.iterator();

                while (iter.hasNext()){

                        feature =(IFeature)iter.next();

                        if (!fm.isDeleted(feature)){

                                if (order != null){

                                        tmpFeatures.add(feature);

                                } else {

                                        tmpFeatures.add(feature.getID());

                                }

                        }

                }

                if (order != null){

                        featureIDs = new ArrayList();

                        iter = tmpFeatures.iterator();

                        while (iter.hasNext()){

                                featureIDs.add(((IFeature)iter.next()).getID());

                        }

                } else {

                        featureIDs = tmpFeatures;

                }

        }

        public int size() {

                return featureIDs.size();

        }

        public Iterator iterator() {

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

                return dbfIter;

        }

        public class FIDIterator implements Iterator{

                private Iterator iter;

                public FIDIterator(Iterator iter){

                        this.iter=iter;

                }

                public boolean hasNext() {

                        checkModified();

                        return iter.hasNext();

                }

                protected void checkModified(){

                        if (modified)

                                throw new ConcurrentModificationException("FeatureCollection modified");

                }

                public Object next() {

                        checkModified();

                        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(){

                this.store.deleteObserver(this);

                this.store = null;

                this.featureType = null;

        }

}