Application: gvSIG desktop

/* 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):

* 2008 {{Company}}   {{Task}}

*/

package org.gvsig.fmap.data.feature.impl;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.data.DataTypes;

import org.gvsig.fmap.data.exceptions.DataException;

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

import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.feature.FeatureReference;

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

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

import org.gvsig.fmap.data.feature.exceptions.DataIndexException;

import org.gvsig.fmap.data.feature.spi.DefaultLongList;

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

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

import org.gvsig.fmap.data.feature.spi.index.FeatureIndexProvider;

import org.gvsig.fmap.data.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.tools.exception.NotYetImplemented;

/**

 * Abstract index provider.

 *

 * @author jyarza

 *

 */

public class DefaultFeatureIndex implements FeatureIndexProviderServices {

        private final FeatureStoreProviderServices featureStore;

        private final FeatureType featureType;

        private final String attributeName;

        private final String name;

        private final int dataType;

        private final FeatureIndexProvider indexProvider;

        public DefaultFeatureIndex(FeatureStoreProviderServices featureStore, FeatureType featureType, FeatureIndexProvider indexProvider, String attributeName, String indexName) {

                if (featureStore == null) {

                        throw new IllegalArgumentException("featureStore cannot be null.");

                }

                if (featureType == null) {

                        throw new IllegalArgumentException("featureType cannot be null.");

                }

                if (attributeName == null) {

                        throw new IllegalArgumentException("attributeName cannot be null.");

                }

                if (indexName == null) {

                        throw new IllegalArgumentException("indexName cannot be null.");

                }

                if (featureStore.getProvider().getFeatureReferenceIdType() != DataTypes.INT) {

                        throw new IllegalArgumentException();

                }

                FeatureAttributeDescriptor attr = featureType.getAttributeDescriptor(attributeName);

                if (attr == null) {

                        throw new IllegalArgumentException("Attribute " + attributeName +" not found in FeatureType " + featureType.toString());

                }

                this.featureStore = featureStore;

                this.featureType = featureType;

                this.attributeName = attributeName;

                this.name = indexName;

                this.dataType = attr.getDataType();

                this.indexProvider = indexProvider;

        }

        public final FeatureAttributeDescriptor getFeatureAttributeDescriptor() {

                return featureType.getAttributeDescriptor(attributeName);

        }

        public final FeatureStoreProviderServices getFeatureStore() {

                return featureStore;

        }

        public final FeatureType getFeatureType() {

                return featureType;

        }

        public final String getName() {

                return name;

        }

        public final String getAttributeName() {

                return attributeName;

        }

        public final int getDataType() {

                return dataType;

        }

        /**

         * Fills this index with all the data in its FeatureStore

         */

        public final void fill() throws DataIndexException {

                try {

                        insert(getFeatureStore().getFeatureSet());

                } catch (DataException e) {

                        throw new DataIndexException(e);

                }

        }

        public final void insert(FeatureSet data) throws DataException {

                Iterator it = data.iterator();

                while (it.hasNext()) {

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

                        insert(feat);

                }

        }

        public void insert(Feature feat) {

                try {

                        indexProvider.insert(feat.get(attributeName), feat.getReference());

                } catch (NullPointerException e) {

                        throw new IllegalArgumentException("Feature does not contain a column with name " + attributeName);

                } catch (ClassCastException e) {

                        throw new IllegalArgumentException("Attribute data type is not valid.");

                }

        }

        public FeatureSetProvider getMatchFeatureSet(Object value)

                        throws DataIndexException {

                return new IndexFeatureSet(this, new DefaultLongList(indexProvider

                                .match(value)));

        }

        public FeatureSetProvider getRangeFeatureSet(Object value1, Object value2)

                        throws DataIndexException {

                return new IndexFeatureSet(this, new DefaultLongList(indexProvider

                                .match(value1, value2)));

        }

        public FeatureSetProvider getNearestFeatureSet(int count, Object value)

                        throws DataIndexException {

                return new IndexFeatureSet(this, new DefaultLongList(indexProvider

                                .nearest(count, value)));

        }

        public FeatureSetProvider getNearestFeatureSet(int count, int tolerance,

                        Object value) throws DataIndexException {

                throw new NotYetImplemented();

        }

        /**

         * Performs a search in the index. The type of search depends on the passed

         * data

         *

         * @deprecated

         * */

        public FeatureSetProvider getFeatureSet(String attrName, Object[] data) throws DataIndexException {

                return new IndexFeatureSet(this, new DefaultLongList(this.match(data)));

        }

        /**

         * Performs a search in the index and returns a list with the elements that

         * match the parameters

         *

         * @deprecated

         */

        private List match(Object[] values) throws DataIndexException {

                if (values == null) {

                        throw new IllegalArgumentException("values can't be null.");

                }

                if (values.length == 0) {

                        throw new IllegalArgumentException("values must contain at least 1 value.");

                }

                List result = null;

                if (values.length == 1) {

                        result = indexProvider.match(values[0]);

                }

                if (values.length == 2) {

                        if (values[0] instanceof Integer && !(values[1] instanceof Integer)) {

                                result = indexProvider.nearest(((Integer)values[0]).intValue(), values[1]);

                        } else {

                                result = indexProvider.match(values[0], values[1]);

                        }

                }

                return result;

        }

        public void initialize() {

                indexProvider.initialize();

        }

        public void delete(Object o, FeatureReference fref) {

                indexProvider.delete(o, fref);

        }

        public void delete(Feature feat) {

                // TODO Auto-generated method stub

        }

        public void delete(FeatureSet data) throws DataIndexException {

                // TODO Auto-generated method stub

        }

        public String[] getAttributeNames() {

                // TODO Auto-generated method stub

                return null;

        }

        /**

         * FIXME ver que hacemos con estas constantes

         * Convenience constants to identify sets of providers classified by supported data types.

         */

        public interface PROVIDERS {

                public interface GEOMETRY {

                        public static final String GT2_QUADTREE = "QuadTreeGt2Factory";

                        public static final String JSI_RTREE = "RTreeJsiFactory";

                        public static final String JTS_QUADTREE = "QuadTreeJtsFactory";

                        public static final String SPATIALINDEX_RTREE = "RTreeSptLibFactory";

                        public static final String DEFAULT = GT2_QUADTREE;

                }

                public interface DATE {

                        // added as example

                }

                public interface INTEGER {

                        // added as example

                }

        }

}