| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {Iver T.I.}   {Task}

 */

package org.gvsig.fmap.dal.cache;

import java.util.HashMap;

import java.util.Iterator;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.cache.CacheFeatureSet.CacheFeatureSetIterator;

import org.gvsig.fmap.dal.cache.envelope.DefaultEnvelopeManager;

import org.gvsig.fmap.dal.cache.envelope.EnvelopeManager;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureReference;

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;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.layers.vectorial.IntersectsEnvelopeEvaluator;

import org.gvsig.fmap.mapcontext.layers.vectorial.IntersectsGeometryEvaluator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorFieldValue;

import org.gvsig.tools.evaluator.EvaluatorFieldValueMatch;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public abstract class AbstractFeatureCacheProvider implements FeatureCacheProvider{

        protected DataServerExplorer dataServerExplorer = null;

        protected static final DataManager dataManager = DALLocator.getDataManager();

        protected FeatureStoreProviderServices featureStoreProviderServices = null;

        protected FeatureStoreProvider featureStoreProvider = null;

        private Envelope fullenvelope = null;

        protected IProjection sourceProjection = null;

        protected FeatureType sourceFeatureType = null;

        //A list of FeatureStores indexed by scale

        protected HashMap featureStores = null;

        //A list of EnvelopeManager indexed by scale

        protected HashMap envelopeManagers = null;

        public AbstractFeatureCacheProvider() {

                super();                

                this.featureStores = new HashMap();

                this.envelopeManagers = new HashMap();

        }

        public void apply(

                        FeatureStoreProviderServices featureStoreProviderServices,

                        FeatureStoreProvider featureStoreProvider) throws DataException {

                this.featureStoreProvider = featureStoreProvider;

                this.featureStoreProviderServices = featureStoreProviderServices;

                this.sourceFeatureType = featureStoreProviderServices.getDefaultFeatureType();

                this.sourceProjection = sourceFeatureType.getDefaultGeometryAttribute().getSRS();

                fullenvelope=featureStoreProvider.getEnvelope();

//                Evaluator evaluator = new IntersectsEnvelopeEvaluator(fullenvelope,

//                                sourceProjection, sourceFeatureType, 

//                                sourceFeatureType.getDefaultGeometryAttributeName());        

//                FeatureQuery newFeatureQuery = featureStoreProviderServices.getFeatureStore().createFeatureQuery();

//                newFeatureQuery.setFilter(evaluator);

//                try {

//                        if(this.sourceProjection.isProjected()){

//                            fullenvelope = GeometryLocator.getGeometryManager().createEnvelope(-10000000, -10000000, 

//                              10000000, 10000000, SUBTYPES.GEOM2D);

//                           }

//                           else{

//                            fullenvelope = GeometryLocator.getGeometryManager().createEnvelope(-180, -90, 

//                             180, 90, SUBTYPES.GEOM2D);

//                           }

//                } catch (Exception e) {

//                        throw new CreateGeometryException(e);

//                }

//                FeatureStore featureStore = featureStoreProviderServices.getFeatureStore();

//                addAllFeatures(featureStore.getFeatureSet(), featureStore.getEnvelope(), 0);                

        }

        public void initialize(DataServerExplorerParameters parameters) throws DataException {

                try{

                        dataServerExplorer = dataManager.createServerExplorer(parameters);

                        if (!dataServerExplorer.canAdd()){

                                throw new CreateException("The server explorer doesn't allow to add data stores", null);

                        }        

                } catch (Exception e) {

                        throw new CreateException("Error creating the server explorer", e);

                } 

        }

        /**

         * Gets an envelope manager by scale.

         * @param scale

         * @return

         */

        private EnvelopeManager getEnvelopeManager(double scale){

                Double iScale = new Double(0);

                if (envelopeManagers.containsKey(iScale)){

                        return (EnvelopeManager)envelopeManagers.get(iScale);

                }

                EnvelopeManager envelopeManager = new DefaultEnvelopeManager();

                envelopeManagers.put(iScale, envelopeManager);

                return envelopeManager;

        }

        /**

         * Gets a feature store by scale. If it not exists, it creates 

         * one using the {@link FeatureStoreProvider}.

         * @param scale

         * @return

         * @throws ValidateDataParametersException

         * @throws LocatorException

         * @throws DataException 

         */

        public FeatureStore getFeatureStore(double scale) throws DataException{

                Double iScale = new Double(scale);

                if (featureStores.containsKey(iScale)){

                        return (FeatureStore)featureStores.get(iScale);

                }

                FeatureStore featureStore = createDataStore(scale);

                featureStores.put(iScale, featureStore);

                return featureStore;

        }

        public boolean allowAutomaticValues() {

                return false;

        }

        public boolean allowWrite() {                

                return false;

        }

        public void append(FeatureProvider featureProvider) throws DataException {

                // TODO Auto-generated method stub

        }

        public void beginAppend() throws DataException {

                // TODO Auto-generated method stub

        }

        public boolean canWriteGeometry(int geometryType, int geometrySubType)

                        throws DataException {                

                return false;

        }

        public FeatureLocks createFeatureLocks() throws DataException {

                return null;

        }

        public FeatureProvider createFeatureProvider(FeatureType type)

                        throws DataException {

                // TODO Auto-generated method stub

                return null;

        }

        public FeatureSelection createFeatureSelection() throws DataException {

                return getFeatureStore(0).createFeatureSelection();

        }

        public Object createNewOID() {

                return null;

        }

        public FeatureSetProvider createSet(FeatureQuery query,

                        FeatureType featureType) throws DataException {

                //If there is not a filter returns the original set of data

                if ((query == null) || (query.getFilter() == null)){

                        Evaluator evaluator = new IntersectsEnvelopeEvaluator(fullenvelope,

                                        sourceProjection, sourceFeatureType, 

                                        sourceFeatureType.getDefaultGeometryAttributeName());        

                        FeatureQuery newFeatureQuery = featureStoreProviderServices.getFeatureStore().createFeatureQuery();

                        newFeatureQuery.setFilter(evaluator);

                        query=newFeatureQuery;

//                        return featureStoreProvider.createSet(query, featureType);

                }

                double scale = 0;//query.getScale();

                FeatureStore featureStore =getFeatureStore(scale);

                EnvelopeManager envelopeManager = getEnvelopeManager(scale);

                Envelope envelope = null;

                EvaluatorFieldsInfo fieldsInfo = query.getFilter().getFieldsInfo();

                String[] fields = fieldsInfo.getFieldNames();

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

                        EvaluatorFieldValue[] evaluatorFieldValues = fieldsInfo.getFieldValues(fields[i]);

                        for (int j=0 ; j<evaluatorFieldValues.length ; j++){                                

                                if (EvaluatorFieldValue.MATCH == evaluatorFieldValues[j].getType()){

                                        EvaluatorFieldValueMatch evaluatorFieldValueMatch = (EvaluatorFieldValueMatch)evaluatorFieldValues[j];

                                        Object area = evaluatorFieldValueMatch.getValue();

                                        if (area instanceof Envelope){

                                                envelope = (Envelope)area;

                                        }else if (area instanceof Geometry){

                                                envelope = ((Geometry)area).getEnvelope();

                                        }

                                }

                        }                        

                }

                //If there is not an envelope returns the original set of data

                if (envelope == null){

                        return featureStoreProvider.createSet(query, featureType);

                }                

                if (!envelopeManager.contains(envelope)){                                

                        //Create a query by geometry        

                        Geometry geometry = envelopeManager.difference(envelope);

                        Evaluator evaluator = new IntersectsGeomAndNotInCacheEvaluator(geometry,

                                        sourceProjection, sourceFeatureType, 

                                        sourceFeatureType.getDefaultGeometryAttributeName(),featureStore);        

                        FeatureQuery newFeatureQuery = featureStoreProviderServices.getFeatureStore().createFeatureQuery();

                        newFeatureQuery.setFilter(evaluator);

                        //Retrieve the features from the source

                        FeatureSetProvider featureSetProvider = featureStoreProvider.createSet(newFeatureQuery, featureType);                        

//                        DisposableIterator iter=featureSetProvider.fastIterator();

//                        while (iter.hasNext()) {

//                                DefaultFeatureProvider object = (DefaultFeatureProvider) iter.next();

//                                System.err.println("feature = "+object.toString());

//                        }

                        //Update the cache

                        addAllFeatures(new CacheFeatureSet(featureStore, featureSetProvider), envelope, scale);

                        //Update the envelope manager

//                        envelopeManager.addEnvelope(envelope);

                }

                return new CacheSetProvider(getFeatureSet(envelope, scale));

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.dal.feature.FeatureCache#getFeatures(org.gvsig.fmap.geom.primitive.Envelope, double)

         */

        public FeatureSet getFeatureSet(Envelope envelope, double scale) throws DataException {

                FeatureStore store = getFeatureStore(scale);

                FeatureType ft=store.getDefaultFeatureType();

                Evaluator evaluator = new IntersectsEnvelopeEvaluator(envelope,

                                sourceProjection, ft, 

                                ft.getDefaultGeometryAttributeName());

                FeatureQuery featureQuery = store.createFeatureQuery();

                featureQuery.setFilter(evaluator);

//                FeatureSet setAll=store.getFeatureSet();

//                DisposableIterator itAll=setAll.iterator();

//                int i=0;

//                while (itAll.hasNext()) {

//                        Feature f = (Feature) itAll.next();

//                        i++;

//                        System.err.println("All i:"+i+" : "+f.getReference().toString());

//                }

//                return setAll;

                FeatureSet set=store.getFeatureSet(featureQuery);

                DisposableIterator it=set.iterator();

                int i=0;

                while (it.hasNext()) {

                        Feature f = (Feature) it.next();

                        i++;

                        System.err.println("Query i:"+i+" : "+f.getReference().toString());

                }

                it.dispose();

                return set;                                

        }

        public void endAppend() throws DataException {

                // TODO Auto-generated method stub

        }

        public Envelope getEnvelope() throws DataException {

                return fullenvelope;

        }

        public long getFeatureCount() throws DataException {

                if (featureStores.size() == 0){

                        return 0;

                }

                //TODO feature count by scale

                Iterator it = featureStores.keySet().iterator();

                long featureNumber = 0;

                while (it.hasNext()){

                        FeatureStore store = (FeatureStore)featureStores.get(it.next());

                        featureNumber = featureNumber + store.getFeatureCount();

                }

                return featureNumber;

        }

        public FeatureProvider getFeatureProviderByReference(

                        FeatureReferenceProviderServices reference) throws DataException {

                // TODO Auto-generated method stub

                return null;

        }

        public FeatureProvider getFeatureProviderByReference(

                        FeatureReferenceProviderServices reference, FeatureType featureType)

                        throws DataException {

                // TODO Auto-generated method stub

                return null;

        }

        public String getName() {

                return null;

        }

        public int getOIDType() {

                // TODO Auto-generated method stub

                return 0;

        }

        public FeatureStoreProviderServices getStoreServices() {

                // TODO Auto-generated method stub

                return null;

        }

        public boolean isLocksSupported() {

                // TODO Auto-generated method stub

                return false;

        }

        public void performChanges(Iterator deleteds, Iterator inserteds,

                        Iterator updateds, Iterator featureTypesChanged)

                        throws DataException {

                // TODO Auto-generated method stub

        }

        public boolean supportsAppendMode() {

                // TODO Auto-generated method stub

                return false;

        }

        public void close() throws CloseException {

                // TODO Auto-generated method stub

        }

        public void dispose() {

                // TODO Auto-generated method stub

        }

        public Iterator getChilds() {

                // TODO Auto-generated method stub

                return null;

        }

        public DataServerExplorer getExplorer() throws ReadException,

                        ValidateDataParametersException {

                // TODO Auto-generated method stub

                return null;

        }

        public Object getSourceId() {

                // TODO Auto-generated method stub

                return null;

        }

        public void open() throws OpenException {

                // TODO Auto-generated method stub

        }

        public void refresh() throws OpenException, InitializeException {

                // TODO Auto-generated method stub

        }

        public void delegate(DynObject dynObject) {

                // TODO Auto-generated method stub

        }

        public DynClass getDynClass() {

                // TODO Auto-generated method stub

                return null;

        }

        public Object getDynValue(String name) throws DynFieldNotFoundException {

                // TODO Auto-generated method stub

                return null;

        }

        public boolean hasDynValue(String name) {

                // TODO Auto-generated method stub

                return false;

        }

        public void implement(DynClass dynClass) {

                // TODO Auto-generated method stub

        }

        public Object invokeDynMethod(String name, DynObject context)

                        throws DynMethodException {

                // TODO Auto-generated method stub

                return null;

        }

        public Object invokeDynMethod(int code, DynObject context)

                        throws DynMethodException {

                // TODO Auto-generated method stub

                return null;

        }

        public void setDynValue(String name, Object value)

                        throws DynFieldNotFoundException {

                // TODO Auto-generated method stub

        }

        public void delete(double scale) throws DataException{

                FeatureStore featureStore = getFeatureStore(scale);

                FeatureSet featureSet = featureStore.getFeatureSet();

                featureStore.edit();

                DisposableIterator it = featureSet.fastIterator();

                while (it.hasNext()){

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

                        featureStore.delete(feature);

                }

                it.dispose();                        

                featureStore.finishEditing();

                //Update the envelope manager

                EnvelopeManager envelopeManager = getEnvelopeManager(scale);

                envelopeManager.delete();                

        }        

        public void deleteAll() throws DataException {

                Iterator it = featureStores.keySet().iterator();

                while (it.hasNext()){

                        Integer scale = (Integer)it.next();

                        delete(scale.intValue());

                }                

        }

        public void addAllFeatures(FeatureSet featureSet, Envelope envelope,

                        double scale) throws DataException {

                        FeatureStore featureStore = getFeatureStore(scale);

                        featureStore.edit();

                        DisposableIterator it = featureSet.fastIterator();

                        while (it.hasNext()){

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

                                System.err.println("Reference= "+((DefaultFeatureReference)feature.getReference()).getOID().toString());

                                EditableFeature editableFeature = featureStore.createNewFeature();

                                copyFeature(editableFeature, feature);

                                featureStore.insert(editableFeature);

                        }

                        it.dispose();                        

                        featureStore.finishEditing();

                        //Update the envelope manager

                        EnvelopeManager envelopeManager = getEnvelopeManager(scale);

                        envelopeManager.addEnvelope(envelope);                        

        }

        /**

         * This method has to be overrided if the cache provider cannot mantain

         * the source {@link FeatureType}

         * @param feature

         * @return

         */

        protected void copyFeature(EditableFeature editableFeature, Feature sourceFeature){

                 editableFeature.copyFrom(sourceFeature);

        }

        public ResourceProvider getResource() {

                // TODO Auto-generated method stub

                return null;

        }

        public void clear() {

                featureStoreProvider.clear();

        }

}