| gvSIG desktop 1

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

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.BitSet;

import java.util.Collection;

import java.util.Iterator;

import java.util.NoSuchElementException;

import org.gvsig.data.ReadException;

import org.gvsig.data.vectorial.AbstractFeatureCollection;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureID;

import org.gvsig.data.vectorial.FeatureType;

//import org.gvsig.data.vectorial.expressionevaluator.FeatureFilter;

import org.gvsig.util.observer.DefaultObservable;

import org.opengis.filter.BinaryComparisonOperator;

import org.opengis.filter.Filter;

import org.opengis.filter.PropertyIsGreaterThan;

//FIXME: OJO Excepciones

public class DBFFeatureCollectionBitSet extends AbstractFeatureCollection {

        protected BitSet bitSet=new BitSet();

        protected DefaultObservable observable = new DefaultObservable();

        protected FeatureType featureType;

        protected DBFStore store;

        protected Filter filter;

        //protected FeatureFilter parser;

        protected long driverFeatureCount;

        protected DBFFeatureCollectionBitSet(DBFStore store,FeatureType type, Filter filter) throws ReadException {

                this.featureType=type;

                this.filter=filter;

                /*if (this.filter!=null)

                        parser = new FeatureFilter(filter,this.featureType);*/

                driverFeatureCount=store.getFeatureCount();

                this.store=store;

                intilizeFeatureIDs();

        }

        public void showMEthods(Class class1){

                System.out.println("--------------");

                System.out.println(class1.getName());

                Method[] metods = class1.getMethods();

                for (int kk=0;kk<metods.length;kk++)

                        System.out.println(metods[kk].toString());

        }

        protected void intilizeFeatureIDs() throws ReadException {

                try{

                        bitSet.clear();

                        if (filter==null){

                                for (int i = 0; i < driverFeatureCount; i++) {

                                        bitSet.set(i);

                                }

                        }else{

                                for (int i = 0; i < driverFeatureCount; i++) {

                                        FeatureID featureID=(FeatureID)createCurrentFeatureID(i);

                                        //TODO:filter previously if possible

                                        /*

                                        showMEthods(Filter.class);

                                        showMEthods(BinaryComparisonOperator.class);

                                        showMEthods(PropertyIsGreaterThan.class);

                                        showMEthods(filter.getClass());

                                        */

                                        //filter.evaluate(null);

                                        if (filter.evaluate(featureID.getFeature(featureType))){

                                                bitSet.set(i);

                                        }

                                }

                        }

                }catch (Exception e) {

                        throw new ReadException("DBFFeatureCollectionBitSet",e);

                }

        }

        protected FeatureID createCurrentFeatureID(long pos){

                if (pos<driverFeatureCount){

                        return new DBFFeatureID((DBFStore)store,pos);

                } else {

                        return null;

                }

        }

        public int size() {

                checkModified();

                return bitSet.cardinality();

        }

        public boolean isEmpty() {

                checkModified();

                return bitSet.isEmpty();

        }

        public boolean contains(Object o) {

                checkModified();

                if (o instanceof Feature){

                        return bitSet.get((int)((DBFFeatureID)((Feature)o).getID()).getIndex());

                }

                return false;

        }

        public Iterator iterator() {

                checkModified();

                DBFBitSetIterator dbfIter=new DBFBitSetIterator(bitSet);

                return dbfIter;

        }

        public Object[] toArray() {

                checkModified();

                ArrayList features= new ArrayList();

                Iterator iterator= this.iterator();

                while(iterator.hasNext()){

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

                        features.add(feature);

                }

                return features.toArray();

        }

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

                checkModified();

                ArrayList features= new ArrayList();

                Iterator iterator= this.iterator();

                while(iterator.hasNext()){

                        Feature feature=(Feature)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) {

                checkModified();

                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 DBFBitSetIterator implements Iterator{

                private BitSet bs;

                private int current=-1;

                public DBFBitSetIterator(BitSet bitSet){

                        this.bs=bitSet;

                }

                public boolean hasNext() {

                        checkModified();

                        return (bs.nextSetBit(current+1) >= 0);

                }

                public Object next() {

                        checkModified();

                        Feature feature=null;

                        if (!this.hasNext()){

                                throw new NoSuchElementException();

                        }

                        current = bs.nextSetBit(current+1);

                        try {

                                feature = createCurrentFeatureID(current).getFeature(featureType);//new DBFFeature(featureType,store,current);

                        } catch (ReadException e) {

                                throw new RuntimeException(e);

                        }

                        return feature;

                }

                public void remove() {

                        throw new UnsupportedOperationException();

                }

        }

        public void dispose() {

                observable.deleteObservers();

                this.observable = null;

                this.bitSet.clear();

                this.featureType = null;

        }

}