Application: gvSIG desktop

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

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

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

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

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

	private DefaultDataIndexes indexes;

	public FeatureIndex createIndex(FeatureType featureType,

			String attributeName, String indexName) throws ProviderNotRegisteredException, InitializeException {

		FeatureIndexProviderServices index = null;

		index = getManager().createDataIndexProvider(this, featureType, featureType.getAttributeDescriptor(attributeName));

		try {

			index.fill();

		} catch (DataIndexException e) {

			throw new InitializeException(index.getName(), e);

		}

		((DefaultDataIndexes) getIndexes()).addIndex(index);						

		return index;

/* 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;

/**

 * 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.");

		}

	}

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

	 * 

	 *  TODO explain 

	 * */

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

	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

		}		

	}	

}

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

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

public class DefaultDataIndexes implements FeatureIndexes {

	public FeatureIndex getDataIndex(FeatureType fType, String attrName) {

			return (FeatureIndex) (indexes.get(attrName));

	public FeatureIndex getDataIndex(String name) {

		return (FeatureIndex) names.get(name);

	public void addIndex(FeatureIndex index) {