Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.spi.memory;

import java.util.ArrayList;

import java.util.Iterator;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.feature.DisposableIterator;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

public abstract class AbstractMemoryStoreProvider extends

                AbstractFeatureStoreProvider {

        protected ArrayList data;

        protected DataStoreParameters parameters;

        public AbstractMemoryStoreProvider(DataStoreParameters parameters) {

                super();

                this.parameters = parameters;

        }

        public FeatureStoreProvider initialize(FeatureStoreProviderServices store)

                        throws InitializeException {

                super.initialize(store);

                return this;

        }

        public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

                throw new UnsupportedOperationException();

        }

        public void addFeatureData(FeatureProvider data) {

                data.setOID(this.createNewOID());

                this.data.add(data);

        }

        public DisposableIterator dataIterator() throws DataException {

                this.open();

                return new DelegatedDisposableIterator(this.data.iterator());

        }

        public DisposableIterator dataIterator(long index) throws DataException {

                this.open();

                return new DelegatedDisposableIterator(this.data

                                .listIterator((int) index));

        }

        public DisposableIterator dataIterator(FeatureType featureType)

                        throws DataException {

                this.open();

                return new DelegatedDisposableIterator(this.data.iterator(),

                                featureType);

        }

        public DisposableIterator dataIterator(long index, FeatureType featureType)

                        throws DataException {

                this.open();

                return new DelegatedDisposableIterator(this.data

                                .listIterator((int) index), featureType);

        }

        public long getDataSize() throws DataException {

                this.open();

                return this.data.size();

        }

        public FeatureProvider getFeatureDataByReference(

                        FeatureReferenceProviderServices reference)

                        throws DataException {

                int oid = ((Long) reference.getOID()).intValue();

                return (FeatureProvider) this.data.get(oid);

        }

        public FeatureProvider getFeatureDataByReference(

                        FeatureReferenceProviderServices reference,

                        FeatureType featureType) throws DataException {

                int oid = ((Long) reference.getOID()).intValue();

                return new MemoryFeatureDataWrapper((DefaultFeatureProvider) this.data

                                .get(oid),

                                featureType);

        }

        public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)

                        throws DataException {

                this.open();

                return new MemoryFeatureSet(this, query, featureType);

        }

        public FeatureProvider createFeatureData(FeatureType featureType)throws DataException  {

                this.open();

                return new DefaultFeatureProvider(featureType);

        }

        public boolean canWriteGeometry(int geometryType, int geometrySubType) {

                // By default memory stores support all geometry types

                return true;

        }

        protected abstract void initializeFeatureTypes() throws InitializeException;

        private class DelegatedDisposableIterator implements DisposableIterator {

                private Iterator delegated;

                private FeatureType fType;

                public DelegatedDisposableIterator(Iterator it) {

                        this(it, null);

                }

                public DelegatedDisposableIterator(Iterator it, FeatureType featureType) {

                        this.delegated = it;

                        this.fType = featureType;

                }

                public void dispose() {

                        this.delegated = null;

                }

                public boolean hasNext() {

                        return delegated.hasNext();

                }

                public Object next() {

                        if (fType == null) {

                                return delegated.next();

                        } else {

                                return new MemoryFeatureDataWrapper(

                                                (DefaultFeatureProvider) delegated.next(),

                                                this.fType);

                        }

                }

                public void remove() {

                        throw new UnsupportedOperationException();

                }

        }

        public long getFeatureCount() throws DataException {

                return data.size();

        }

}