| gvSIG desktop 1

The project structure of this project is the following:

Project

|-pom.xml:   		Maven 2 configuration file.

`-src

  |-main:    		Project source code, resources and configuration

  | |-java:  		Java source code

  | |-resources:	Resources needed by the code (resource bundles, images, etc.)   

  |`-javadoc:		Javadoc common resources	

  `-test:    		Unit tests source code, resources and configuration

    |-java:  		Unit tests java source code

    `-resources:	Resources needed by the test code (resource bundles, images, etc.)   

Look at the main folders for a README.txt file with more information on the 

contents of each folder.

/* 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.store.memory;

import java.util.ArrayList;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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.EditableFeatureAttributeDescriptor;

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

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

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

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

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

import org.gvsig.fmap.dal.store.memory.MemoryStoreParameters;

import org.gvsig.fmap.dal.store.memory.MemoryStoreProvider;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

 */

public class MemoryStoreProviderCacheTest extends org.gvsig.fmap.dal.store.memory.MemoryStoreProviderTest {

	private Logger logger = LoggerFactory.getLogger(getClass());;

	protected FeatureStore createEditableFeatureStore() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException{

		FeatureStore store = (FeatureStore) dataManager.createStore(this

				.getDefaultDataStoreParameters());

		store.edit();

		EditableFeatureType editableFeatureType = store.getDefaultFeatureType().getEditable();

		editableFeatureType.add(ID, DataTypes.OBJECT).setObjectClass(Object.class);

		EditableFeatureAttributeDescriptor geometryDescriptor = 

			editableFeatureType.add(GEOM, DataTypes.GEOMETRY);

		geometryDescriptor.setGeometryType(TYPES.GEOMETRY);

		editableFeatureType.setDefaultGeometryAttributeName(GEOM);

		editableFeatureType.add(IDSYM, DataTypes.OBJECT).setObjectClass(Object.class);

		editableFeatureType.add(LABEL, DataTypes.STRING);

		EditableFeatureAttributeDescriptor featureIdDescriptor = 

			editableFeatureType.add(FEATUREID, DataTypes.OBJECT).setObjectClass(Object.class);

		featureIdDescriptor.setIsPrimaryKey(true);

		editableFeatureType.setHasOID(true);

		store.update(editableFeatureType);	

		store.finishEditing();

		return store;

	}

	public void testEdition() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException, CreateGeometryException{

		FeatureStore store = createEditableFeatureStore();

		store.edit();

		EditableFeature feature = store.createNewFeature().getEditable();

		feature.set(ID, "0");

		feature.set(GEOM, geomManager.createPoint(0, 0, SUBTYPES.GEOM2D));

		store.insert(feature);

		store.finishEditing();

		store.edit();

		DisposableIterator it = store.getFeatureSet().fastIterator();

		ArrayList features = new ArrayList();

		while (it.hasNext()){

			features.add(it.next());			

		}

		for (int i=0 ; i<features.size() ; i++){

			store.delete((Feature)features.get(i));

		}	

		store.finishEditing();

		assertEquals(0, store.getFeatureCount());

	}

}

/* 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 org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

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

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

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

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

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.store.shp.SHPLibrary;

import org.gvsig.fmap.dal.store.wfs.WFSLibrary;

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

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

/**

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

 */

public abstract class AbstractFeatureCacheProviderTest extends AbstractLibraryAutoInitTestCase{

	protected DataManagerProviderServices dataManager;

	protected FeatureStore store0;

	protected FeatureStore store1;

	protected void doSetUp() throws Exception {		

		new SHPLibrary().postInitialize();

		new WFSLibrary().postInitialize();

		dataManager = (DataManagerProviderServices)DALLocator.getDataManager();		

	}

	protected abstract FeatureStore createStore1() throws Exception;

	protected abstract FeatureStore createStore2() throws Exception;;

	public void testCreateProvider() throws DataException{

		FeatureCacheProvider cacheProvider =

			dataManager.createFeatureCacheProvider(getCacheProviderName(),

					getParameters());

		assertNotNull(cacheProvider);

	}	

	public void testCreateCache() throws Exception{

		store0 = createStore1();		

		store0.createCache(getCacheProviderName(),

				getParameters());		

		FeatureCache cache = store0.getCache();

		assertNotNull(cache);

		store0.dispose();		

	}

	public void testNumberOfFeatures() throws Exception{

		store0 = createStore1();		

		long featureNumber = store0.getFeatureCount();

		FeatureSet featureSet = store0.getFeatureSet();	

		Envelope envelope = store0.getEnvelope();

		store0.createCache(getCacheProviderName(),

				getParameters());

		FeatureCache cache = store0.getCache();

		cache.addAllFeatures(featureSet, envelope, 0);

		assertEquals(featureNumber, store0.getFeatureCount());	

		store0.dispose();	

	}

	public void testAddFeatures() throws Exception{

		store0 = createStore1();	

		store1 = createStore2();

		long featureNumber = store0.getFeatureCount();

		featureNumber = featureNumber + store1.getFeatureCount();

		FeatureSet featureSet = store0.getFeatureSet();	

		Envelope envelope = store0.getEnvelope();

		store0.createCache(getCacheProviderName(),

				getParameters());					

		FeatureCache cache = store0.getCache();

		cache.addAllFeatures(featureSet, envelope, 0);

		cache.addAllFeatures(store1.getFeatureSet(),

				store1.getEnvelope(),

				0);

		assertEquals(featureNumber, store0.getFeatureCount());

		featureSet.dispose();

		store0.dispose();

		store1.dispose();

	}	

	protected abstract DataServerExplorerParameters getParameters() throws DataException;

	protected abstract String getCacheProviderName();

}

package org.gvsig.fmap.dal.cache.shp;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

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

import org.gvsig.fmap.dal.store.wfs.WFSStoreParameters;

import org.gvsig.fmap.dal.store.wfs.WFSStoreProvider;

import org.gvsig.fmap.geom.GeometryLocator;

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

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

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

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.locator.LocatorException;

public class FeatureCacheShapeProviderFromWFSTest extends FeatureCacheShapeProviderTest{

	private String url = "http://fuenlabrada.iver.es/geoserver-test/wfs";

	private String version = "1.1.0";

	private String featureType = "fuenlabrada:pois";

	private String namespace = "http://fuenlabrada.iver.es";

	private String namespacePrefix = "fuenlabrada";	

	@Override

	protected FeatureStore createStore1() throws Exception {

		WFSStoreParameters parameters = null;

		parameters = (WFSStoreParameters) dataManager

		.createStoreParameters(WFSStoreProvider.NAME);

		parameters.setUrl(url);

		parameters.setFeatureType(namespacePrefix, 

				namespace, 

				featureType);

		parameters.setVersion(version);

		return (FeatureStore)dataManager.createStore(parameters);		

	}

	@Override

	protected FeatureStore createStore2() throws Exception {

		WFSStoreParameters parameters = null;

		parameters = (WFSStoreParameters) dataManager

		.createStoreParameters(WFSStoreProvider.NAME);

		parameters.setUrl(url);

		parameters.setFeatureType(namespacePrefix, 

				namespace, 

				featureType);

		parameters.setVersion(version);

		return (FeatureStore)dataManager.createStore(parameters);

	}

	public void testFilterByArea() throws Exception{

		store0 = createStore1();	

		store0.createCache(getCacheProviderName(),

				getParameters());	

		Envelope envelope = GeometryLocator.getGeometryManager().createEnvelope(

				420000, 4450000, 445000, 4470000, SUBTYPES.GEOM2D);		

		Evaluator evaluator = new IntersectsEnvelopeEvaluator(envelope,

				CRSFactory.getCRS("EPSG:23030"), store0.getDefaultFeatureType(), "the_geom");

		FeatureQuery featureQuery = store0.createFeatureQuery();

		featureQuery.setFilter(evaluator);

		FeatureSet featureSet = store0.getFeatureSet(featureQuery);

		assertEquals(18, store0.getFeatureCount());

		store0.dispose();

	}

}

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

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.cache.AbstractFeatureCacheProviderTest;

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

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

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

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

import org.gvsig.fmap.dal.store.shp.SHPStoreParameters;

/**

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

 */

public class FeatureCacheShapeProviderFromShapeTest extends FeatureCacheShapeProviderTest{

	@Override

	protected FeatureStore createStore1() throws Exception {

		return createStore(AbstractFeatureCacheProviderTest.class.getResource("data/points0.shp").getFile());	

	}

	@Override

	protected FeatureStore createStore2() throws Exception{

		return createStore(AbstractFeatureCacheProviderTest.class.getResource("data/points1.shp").getFile());

	}

	private FeatureStore createStore(String fileName) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException{

		SHPStoreParameters parameters = (SHPStoreParameters)dataManager.createStoreParameters("Shape");

		parameters.setSHPFileName(fileName);		

		parameters.setDynValue("srs", CRSFactory.getCRS("EPSG:23030"));

		return (FeatureStore)dataManager.createStore(parameters);

	}

}

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

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.cache.AbstractFeatureCacheProviderTest;

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

/**

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

 */

public abstract class FeatureCacheShapeProviderTest extends AbstractFeatureCacheProviderTest{

	@Override

	protected String getCacheProviderName() {

		return FeatureCacheShapeProvider.NAME;

	}

	@Override

	protected DataServerExplorerParameters getParameters() throws DataException {

		FilesystemServerExplorerParameters eparams = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters("FilesystemExplorer");

		eparams.setRoot(AbstractFeatureCacheProviderTest.class.getResource("data").getFile());

		return eparams;

	}

}

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

For each class you are going to test, create one Test class with the same

name as the class to test, ending with Test.

For example, the unit tests of the "ExampleLibrary" class are performed

by the "ExampleLibraryTest" class.

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	DefaultExampleManager class.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.fmap.dal.cache.impl.DefaultExampleManager">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

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

import org.gvsig.fmap.dal.DataStore;

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

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.FeatureSet;

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

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

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.Visitor;

/**

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

 */

public class CacheFeatureSet implements FeatureSet{

	private FeatureSetProvider featureSetProvider = null;

	private FeatureStore store = null;

	public CacheFeatureSet(FeatureStore store, FeatureSetProvider featureSetProvider) {

		this.featureSetProvider = featureSetProvider;

		this.store = store;

	}

	public void delete(Feature feature) throws DataException {

		// TODO Auto-generated method stub

	}

	public DisposableIterator fastIterator() throws DataException {

		return new CacheFeatureSetIterator(featureSetProvider.fastIterator());

	}

	public DisposableIterator fastIterator(long index) throws DataException {

		return new CacheFeatureSetIterator(featureSetProvider.fastIterator(index));

	}

	public FeatureType getDefaultFeatureType() {

		// TODO Auto-generated method stub

		return null;

	}

	public List getFeatureTypes() {

		// TODO Auto-generated method stub

		return null;

	}

	public long getSize() throws DataException {

		// TODO Auto-generated method stub

		return 0;

	}

	public void insert(EditableFeature feature) throws DataException {

		// TODO Auto-generated method stub

	}

	public boolean isEmpty() throws DataException {

		// TODO Auto-generated method stub

		return false;

	}

	public DisposableIterator iterator(long index) throws DataException {

		return new CacheFeatureSetIterator(featureSetProvider.fastIterator(index));

	}

	public DisposableIterator iterator() throws DataException {

		return new CacheFeatureSetIterator(featureSetProvider.fastIterator());

	}

	public void update(EditableFeature feature) throws DataException {

		// TODO Auto-generated method stub

	}

	public void dispose() {

		// TODO Auto-generated method stub

	}

	public boolean isFromStore(DataStore store) {

		// TODO Auto-generated method stub

		return false;

	}

	public void accept(Visitor visitor) throws BaseException {

		// TODO Auto-generated method stub

	}

	public void accept(Visitor visitor, long firstValueIndex)

			throws BaseException {

		// TODO Auto-generated method stub

	}

	protected class CacheFeatureSetIterator implements DisposableIterator {

		protected DisposableIterator iterator;

		public CacheFeatureSetIterator(DisposableIterator iterator) throws DataException {

			this.iterator = iterator;

		}

		public void dispose() {

			// TODO Auto-generated method stub

		}

		public boolean hasNext() {

			return iterator.hasNext();

		}

		public Object next() {

			return new DefaultFeature(store, (FeatureProvider)iterator.next());	

		}

		public void remove() {

			// TODO Auto-generated method stub			

		}

	}

}

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

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

import org.gvsig.fmap.geom.Geometry;

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

/**

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

 */

public interface EnvelopeManager {

	public void addEnvelope(Envelope envelope);	

	public void delete();

	public boolean contains(Envelope envelope);

	public Geometry intersection(Envelope envelope) throws CreateGeometryException;

	public Geometry difference(Envelope envelope) throws CreateGeometryException;

	public Geometry getCachedArea() throws CreateGeometryException;

}

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.fmap.geom.util.Converter;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.impl.PackedCoordinateSequence;

/**

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

 */

public class DefaultEnvelopeManager implements EnvelopeManager{

	private GeometryManager geometryManager = GeometryLocator.getGeometryManager();

	private final static com.vividsolutions.jts.geom.GeometryFactory geomFactory = 

		new com.vividsolutions.jts.geom.GeometryFactory();

	com.vividsolutions.jts.geom.MultiPolygon currentArea = null;

	public DefaultEnvelopeManager() {

		super();		

	}

	/* (non-Javadoc)

	 * @see org.gvsig.cache.vectorial.envelope.EnvelopeManager#addEnvelope(org.gvsig.fmap.geom.primitive.Envelope)

	 */

	public void addEnvelope(Envelope envelope) {

		if (currentArea == null){

			currentArea = toJTS(envelope);

		}else{

			Geometry geom = currentArea.union(toJTS(envelope));

			if(geom instanceof Polygon)

				currentArea = new MultiPolygon(new Polygon[] {(Polygon)geom},geomFactory);

			else {

				currentArea = (MultiPolygon)geom;

			}

			//			currentArea = (com.vividsolutions.jts.geom.MultiPolygon)currentArea.union(toJTS(envelope));

		}			

	}

	private void initialize(){

		Polygon polygon = new com.vividsolutions.jts.geom.Polygon(new LinearRing(new PackedCoordinateSequence.Double(new Coordinate[0]),

				geomFactory),

				new LinearRing[0], geomFactory);

		currentArea = new MultiPolygon(new Polygon[] {polygon},geomFactory);				

	}

	private com.vividsolutions.jts.geom.MultiPolygon toJTS(Envelope envelope){

		return toJTS(envelope.getMinimum(0),

				envelope.getMinimum(1),

				envelope.getMaximum(0),

				envelope.getMaximum(1));

	}

	private com.vividsolutions.jts.geom.MultiPolygon toEnvelope(com.vividsolutions.jts.geom.Envelope envelope){

		return toJTS(envelope.getMinX(),

				envelope.getMinY(),

				envelope.getMaxX(),

				envelope.getMaxY());

	}

	private com.vividsolutions.jts.geom.MultiPolygon toJTS(double minX, double minY, double maxX, double maxY){

		Coordinate[] coordinates = new Coordinate[5];

		coordinates[0] = new Coordinate(minX, minY);

		coordinates[1] = new Coordinate(minX, maxY);

		coordinates[2] = new Coordinate(maxX, maxY);

		coordinates[3] = new Coordinate(maxX, minY);

		coordinates[4] = new Coordinate(minX, minY);

		Polygon polygon = new com.vividsolutions.jts.geom.Polygon(new LinearRing(new PackedCoordinateSequence.Double(coordinates),

				geomFactory),

				new LinearRing[0], geomFactory);

		return new MultiPolygon(new Polygon[] {polygon},geomFactory);

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.EnvelopeManager#contains(org.gvsig.fmap.geom.primitive.Envelope)

	 */

	public boolean contains(Envelope envelope) {

		if (currentArea == null){

			initialize();

		}

		return currentArea.contains(toJTS(envelope));

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.EnvelopeManager#delete()

	 */

	public void delete() {

		initialize();

	}

	/* (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.EnvelopeManager#getCachedArea()

	 */

	public org.gvsig.fmap.geom.Geometry getCachedArea() throws org.gvsig.fmap.dal.feature.exception.CreateGeometryException {

		if (currentArea == null){

			initialize();

		}

		try {

			return Converter.jtsToGeometry(currentArea);

		} catch (CreateGeometryException e) {

			throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.EnvelopeManager#intersection(org.gvsig.fmap.geom.primitive.Envelope)

	 */

	public org.gvsig.fmap.geom.Geometry intersection(Envelope envelope) throws org.gvsig.fmap.dal.feature.exception.CreateGeometryException {

		if (currentArea == null){

			initialize();

		}

		Geometry intersection = currentArea.intersection(toJTS(envelope));

		try {

			return Converter.jtsToGeometry(intersection);	

		} catch (CreateGeometryException e) {

			throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.feature.EnvelopeManager#difference(org.gvsig.fmap.geom.primitive.Envelope)

	 */

	public org.gvsig.fmap.geom.Geometry difference(Envelope envelope) throws org.gvsig.fmap.dal.feature.exception.CreateGeometryException {

		if (currentArea == null){

			initialize();

		}

		Geometry difference = toJTS(envelope).difference(currentArea);

		try{

			return Converter.jtsToGeometry(difference);	

		} catch (CreateGeometryException e) {

			throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);

		}

	}

}

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

		try {

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

					10000000, 10000000, 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(scale);

		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 

	 */

	private 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 {

		// TODO Auto-generated method stub

		return null;

	}

	public Object createNewOID() {

		// TODO Auto-generated method stub

		return null;

	}

	public FeatureSetProvider createSet(FeatureQuery query,

			FeatureType featureType) throws DataException {

		double scale = query.getScale();

		FeatureStore featureStore = getFeatureStore(scale);

		EnvelopeManager envelopeManager = getEnvelopeManager(scale);

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

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

			return featureStoreProvider.createSet(query, featureType);

		}

		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 IntersectsGeometryEvaluator(geometry,

					sourceProjection, sourceFeatureType, 

					sourceFeatureType.getDefaultGeometryAttributeName());	

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

			newFeatureQuery.setFilter(evaluator);

			//Retrieve the features from the source

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

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

		Evaluator evaluator = new IntersectsEnvelopeEvaluator(envelope,

				sourceProjection, sourceFeatureType, 

				sourceFeatureType.getDefaultGeometryAttributeName());

		FeatureQuery featureQuery = store.createFeatureQuery();

		featureQuery.setFilter(evaluator);

		return store.getFeatureSet(featureQuery);				

	}

	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