/ - Diff - Application: gvSIG desktop - gvSIG

Revision 44618

      * AUTHORS (In addition to CIT):
      * 2009 {Iver T.I.}   {Task}
      */
     package org.gvsig.fmap.dal.store.memory;
     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataStoreParameters;
-...
     import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;
     import org.gvsig.fmap.dal.exception.ValidateDataParametersException;
     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.feature.OpenFeatureStoreParameters;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.Geometry.SUBTYPES;
     import org.gvsig.fmap.geom.Geometry.TYPES;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.GeometryUtils;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.Curve;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.Surface;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class MemoryStoreProviderTest extends AbstractLibraryAutoInitTestCase {
     	protected Logger logger = LoggerFactory.getLogger(getClass());;
     	protected static DataManager dataManager = null;
     	protected static GeometryManager geomManager = null;
     	protected static final String ID = "id";
     	protected static final String GEOM = "geom";
     	protected static final String IDSYM = "idsym";
     	protected static final String LABEL = "label";
     	protected static final String FEATUREID = "featureid";
         protected static final Logger LOGGER = LoggerFactory.getLogger(MemoryStoreProviderTest.class);
     	protected void doSetUp() throws Exception {
     		dataManager = DALLocator.getDataManager();
     		geomManager = GeometryLocator.getGeometryManager();
+    	}
         protected static final String ID = "id";
         protected static final String GEOM = "geom";
         protected static final String IDSYM = "idsym";
         protected static final String LABEL = "label";
         protected static final String FEATUREID = "featureid";
     	/*
     	 * (non-Javadoc)
     	 * @see org.gvsig.fmap.dal.feature.BaseTestFeatureStore#getDefaultDataStoreParameters()
     	 */
     	public DataStoreParameters getDefaultDataStoreParameters()
     	throws DataException {
     		MemoryStoreParameters memoryParameters = null;
         @Override
         protected void doSetUp() throws Exception {
+        }
     		memoryParameters = (MemoryStoreParameters) dataManager
     		.createStoreParameters(MemoryStoreProvider.NAME);
     		return memoryParameters;
+    	}
         public OpenFeatureStoreParameters createMemoryStoreParameters() throws DataException {
             DataManager dataManager = DALLocator.getDataManager();
             MemoryStoreParameters memoryParameters = (MemoryStoreParameters) dataManager
                     .createStoreParameters(MemoryStoreProvider.NAME);
             return memoryParameters;
+        }
     	public void testInitializeStore() throws Exception {
                     DataStoreParameters params = this.getDefaultDataStoreParameters();
     		FeatureStore store = (FeatureStore) dataManager.openStore(
                             params.getDataStoreName(),params
                     );
         protected FeatureStore createStoreWithGeomField() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException {
             DataManager dataManager = DALLocator.getDataManager();
             DataStoreParameters params = this.createMemoryStoreParameters();
             FeatureStore store = (FeatureStore) dataManager.openStore(
                     params.getProviderName(),
                     params
             );
             store.edit();
             EditableFeatureType editableFeatureType = store.getDefaultFeatureType().getEditable();
             editableFeatureType.add(ID, DataTypes.OBJECT)
                     .setIsPrimaryKey(true)
                     .setObjectClass(Object.class);
             editableFeatureType.add(IDSYM, DataTypes.OBJECT)
                     .setObjectClass(Object.class);
             editableFeatureType.add(GEOM, DataTypes.GEOMETRY)
                     .setGeometryType(Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);
             editableFeatureType.add(LABEL, DataTypes.STRING);
             editableFeatureType.add(FEATUREID, DataTypes.OBJECT)
                     .setObjectClass(Object.class);
     		assertNotNull(store.getMetadataID());
     		assertNotNull(store.getName());
     		assertEquals(store.getEnvelope(), store.getDynValue("Envelope"));
     		assertTrue(store.getFeatureCount() == 0);
     		if (store.isLocksSupported()) {
     			assertNotNull(store.getLocks());
     		} else {
     			assertNull(store.getLocks());
+    		}
     		store.dispose();
+    	}
             store.update(editableFeatureType);
             store.finishEditing();
             return store;
+        }
         protected FeatureStore createStoreWithoutGeomField() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException {
             DataManager dataManager = DALLocator.getDataManager();
             DataStoreParameters params = this.createMemoryStoreParameters();
             FeatureStore store = (FeatureStore) dataManager.openStore(
                     params.getProviderName(),
                     params
             );
             store.edit();
             EditableFeatureType editableFeatureType = store.getDefaultFeatureType().getEditable();
             editableFeatureType.add(ID, DataTypes.OBJECT)
                     .setIsPrimaryKey(true)
                     .setObjectClass(Object.class);
             editableFeatureType.add(IDSYM, DataTypes.OBJECT)
                     .setObjectClass(Object.class);
             editableFeatureType.add(LABEL, DataTypes.STRING);
             editableFeatureType.add(FEATUREID, DataTypes.OBJECT)
                     .setObjectClass(Object.class);
     	public void testAddFeatureType() throws DataException, ValidateDataParametersException{
     		FeatureStore store = createEditableFeatureStore();
     		FeatureAttributeDescriptor attributeDescriptor = store.getDefaultFeatureType().getAttributeDescriptor(ID);
     		assertNotNull(attributeDescriptor);
     		assertEquals(attributeDescriptor.getType(), DataTypes.OBJECT);
             store.update(editableFeatureType);
             store.finishEditing();
             return store;
+        }
         protected FeatureStore createStoreWithGeomFieldFilled(List<Geometry> geoms) throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException {
             FeatureStore store = createStoreWithGeomField();
     		store.dispose();
+    	}
             store.edit();
             int id = -1;
             geoms.add(GeometryUtils.createPoint(1, 1));
             geoms.add(GeometryUtils.createLine(Geometry.SUBTYPES.GEOM2D)
                 .addVertex(0, 0)
                 .addVertex(1, 0)
                 .addVertex(1, 1)
                 .addVertex(0, 1)
                 .addVertex(0, 0));
             geoms.add(GeometryUtils.createPolygon(Geometry.SUBTYPES.GEOM2D)
                 .addVertex(0, 0)
                 .addVertex(1, 0)
                 .addVertex(1, 1)
                 .addVertex(0, 1)
                 .addVertex(0, 0));
             EditableFeature feature;
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             feature.set(GEOM, geoms.get(id));
             store.insert(feature);
     	protected FeatureStore createEditableFeatureStore() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException{
                     DataStoreParameters params = this.getDefaultDataStoreParameters();
     		FeatureStore store = (FeatureStore) dataManager.openStore(
                             params.getDataStoreName(),params
                     );
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             feature.set(GEOM, geoms.get(id));
             store.insert(feature);
     		store.edit();
     		EditableFeatureType editableFeatureType = store.getDefaultFeatureType().getEditable();
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             feature.set(GEOM, geoms.get(id));
             store.insert(feature);
     		EditableFeatureAttributeDescriptor idDescriptor = editableFeatureType.add(ID, DataTypes.OBJECT).setObjectClass(Object.class);
     		idDescriptor.setIsPrimaryKey(true);
     		EditableFeatureAttributeDescriptor geometryDescriptor =
     			editableFeatureType.add(GEOM, DataTypes.GEOMETRY);
     		geometryDescriptor.setGeometryType(TYPES.GEOMETRY);
     		editableFeatureType.setDefaultGeometryAttributeName(GEOM);
             Envelope envelope = store.getEnvelope();
             assertNotNull(envelope);
     		editableFeatureType.add(IDSYM, DataTypes.OBJECT).setObjectClass(Object.class);
     		editableFeatureType.add(LABEL, DataTypes.STRING);
     		EditableFeatureAttributeDescriptor featureIdDescriptor =
     			editableFeatureType.add(FEATUREID, DataTypes.OBJECT).setObjectClass(Object.class);
     		//editableFeatureType.setHasOID(true);
             store.finishEditing();
             return store;
+        }
         protected FeatureStore createStoreWithoutGeomFieldFilled() throws ValidateDataParametersException, InitializeException, ProviderNotRegisteredException, DataException {
             FeatureStore store = createStoreWithoutGeomField();
     		store.update(editableFeatureType);
     		store.finishEditing();
     		return store;
+    	}
             store.edit();
             int id = 0;
             EditableFeature feature;
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             store.insert(feature);
     	public void testAddFeature() throws DataException, ValidateDataParametersException, CreateGeometryException{
     		FeatureStore store = createEditableFeatureStore();
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             store.insert(feature);
     		store.edit();
     		EditableFeature feature = store.createNewFeature().getEditable();
     		feature.set(ID, "0");
     		feature.set(GEOM, geomManager.createPoint(0, 0, SUBTYPES.GEOM2D));
             feature = store.createNewFeature();
             feature.set(ID, ++id);
             feature.set(LABEL, "Hi");
             store.insert(feature);
     		store.insert(feature);
             Envelope envelope = store.getEnvelope();
             assertNull(envelope);
     		Envelope envelope = store.getEnvelope();
     		assertNotNull(envelope);
             store.finishEditing();
             return store;
+        }
     		store.finishEditing();
         public void testInitializeStore() throws Exception {
             DataManager dataManager = DALLocator.getDataManager();
             DataStoreParameters params = this.createMemoryStoreParameters();
             FeatureStore store = (FeatureStore) dataManager.openStore(
                     params.getProviderName(),
                     params
             );
             assertNotNull(store.getMetadataID());
             assertNotNull(store.getName());
             assertEquals(store.getEnvelope(), store.getDynValue("Envelope"));
             assertTrue(store.getFeatureCount() == 0);
             if (store.isLocksSupported()) {
                 assertNotNull(store.getLocks());
             } else {
                 assertNull(store.getLocks());
+            }
             store.dispose();
+        }
     		FeatureSet featureSet = store.getFeatureSet();
     		DisposableIterator it = featureSet.fastIterator();
     		while (it.hasNext()){
     			Feature feature2 = (Feature)it.next();
     			assertEquals(feature.getType().get(0), feature2.getType().get(0));
     			assertEquals(feature.get(0), feature2.get(0));
         public void testAddFeatureType() throws DataException, ValidateDataParametersException {
             FeatureStore store = createStoreWithGeomField();
             FeatureAttributeDescriptor attributeDescriptor = store.getDefaultFeatureType()
                     .getAttributeDescriptor(ID);
             assertNotNull(attributeDescriptor);
             assertEquals(attributeDescriptor.getType(), DataTypes.OBJECT);
     			assertEquals(feature.getType().get(1), feature2.getType().get(1));
     			assertEquals(feature.get(1), feature2.get(1));
+    		}
             store.dispose();
+        }
     		envelope = store.getEnvelope();
     		assertNotNull(envelope);
         public void testAddFeaturesWithGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             List<Geometry> geoms = new ArrayList<>();
             FeatureStore store = createStoreWithGeomFieldFilled(geoms);
             int n = -1;
             for (Feature feature : store.getFeatureSet()) {
                 assertEquals(++n, feature.get(ID));
                 assertEquals(geoms.get(n), feature.get(GEOM));
+            }
     		store.dispose();
+    	}
             store.edit();
             EditableFeature feature = store.createNewFeature();
             feature.set(ID, 4);
             feature.set(GEOM, GeometryUtils.createPolygon(Geometry.SUBTYPES.GEOM2D)
                 .addVertex(0, 0)
                 .addVertex(1, 0)
                 .addVertex(1, 1)
                 .addVertex(0, 1)
                 .addVertex(0, 0)
             );
             store.insert(feature);
             store.finishEditing();
             assertEquals(4, store.getFeatureCount());
             store.dispose();
+        }
     	public void testAddFeatures() throws DataException, ValidateDataParametersException, CreateGeometryException{
     		FeatureStore store = createEditableFeatureStore();
         public void testRemoveFeaturesWithGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             List<Geometry> geoms = new ArrayList<>();
             FeatureStore store = createStoreWithGeomFieldFilled(geoms);
     		store.edit();
             Feature f;
             store.edit();
             FeatureSet featureSet = store.getFeatureSet();
             DisposableIterator it = featureSet.fastIterator();
             it.next();
             f = (Feature) it.next();
             store.delete(f);
             store.finishEditing();
     		EditableFeature feature = store.createNewFeature().getEditable();
     		feature.set(ID, "0");
     		feature.set(GEOM, geomManager.createPoint(0, 0, SUBTYPES.GEOM2D));
             assertEquals(2, store.getFeatureCount());
             store.dispose();
+        }
     		// One
     		store.insert(feature);
         public void testUpdateFeaturesWithGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             List<Geometry> geoms = new ArrayList<>();
             FeatureStore store = createStoreWithGeomFieldFilled(geoms);
     		EditableFeature feature2 = store.createNewFeature().getEditable();
     		feature2.set(ID, "1");
     		Curve curve =  geomManager.createCurve(Geometry.SUBTYPES.GEOM2D);
     		curve.addVertex(0,0);
     		curve.addVertex(1,0);
     		curve.addVertex(1,1);
     		curve.addVertex(0,1);
     		curve.addVertex(0,0);
     		feature2.set(GEOM, curve);
             store.edit();
             FeatureSet set = store.getFeatureSet();
             for (Feature feature : set) {
                 EditableFeature ef = feature.getEditable();
                 ef.set(LABEL, "Bye");
                 set.update(ef);
+            }
             store.finishEditing();
     		// Two
     		store.insert(feature2);
             for (Feature feature : store.getFeatureSet()) {
                 assertEquals("Bye", feature.get(LABEL));
+            }
             store.dispose();
+        }
     		EditableFeature feature3 = store.createNewFeature().getEditable();
     		feature3.set(ID, "2");
     		Surface surface =  geomManager.createSurface(Geometry.SUBTYPES.GEOM2D);
     		surface.addVertex(0,0);
     		surface.addVertex(1,0);
     		surface.addVertex(1,1);
     		surface.addVertex(0,1);
     		surface.addVertex(0,0);
     		feature3.set(GEOM, surface);
         public void testAddFeaturesWithoutGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             FeatureStore store = createStoreWithoutGeomFieldFilled();
             int n = 0;
             for (Feature feature : store.getFeatureSet()) {
                 assertEquals(++n, feature.get(ID));
+            }
     		//Three
     		store.insert(feature3);
             store.edit();
             EditableFeature feature = store.createNewFeature();
             feature.set(ID, 4);
             store.insert(feature);
             store.finishEditing();
             assertEquals(4, store.getFeatureCount());
             store.dispose();
+        }
     		Envelope envelope = store.getEnvelope();
     		assertNotNull(envelope);
         public void testRemoveFeaturesWithoutGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             FeatureStore store = createStoreWithoutGeomFieldFilled();
     		store.finishEditing();
             Feature f;
             store.edit();
             FeatureSet featureSet = store.getFeatureSet();
             DisposableIterator it = featureSet.fastIterator();
             it.next();
             f = (Feature) it.next();
             store.delete(f);
             store.finishEditing();
     		FeatureSet featureSet = store.getFeatureSet();
     		DisposableIterator it = featureSet.fastIterator();
             assertEquals(2, store.getFeatureCount());
             store.dispose();
+        }
     		//Count the features in the set
     		int i=0;
     		while (it.hasNext()){
     			Feature feat = (Feature)it.next();
     			i++;
+    		}
         public void testUpdateFeaturesWithoutGeom() throws DataException, ValidateDataParametersException, CreateGeometryException {
             FeatureStore store = createStoreWithoutGeomFieldFilled();
     		//Are all three inside?
     		assertEquals(3,i);
             store.edit();
             FeatureSet set = store.getFeatureSet();
             for (Feature feature : set) {
                 EditableFeature ef = feature.getEditable();
                 ef.set(LABEL, "Bye");
                 set.update(ef);
+            }
             store.finishEditing();
     		envelope = store.getEnvelope();
     		assertNotNull(envelope);
             for (Feature feature : store.getFeatureSet()) {
                 assertEquals("Bye", feature.get(LABEL));
+            }
             store.dispose();
+        }
     		// Editing other time
     		store.edit();
     		EditableFeature feature4 = store.createNewFeature().getEditable();
     		feature4.set(ID, "4");
     		surface =  geomManager.createSurface(Geometry.SUBTYPES.GEOM2D);
     		surface.addVertex(0,0);
     		surface.addVertex(1,0);
     		surface.addVertex(1,1);
     		surface.addVertex(0,1);
     		surface.addVertex(0,0);
     		feature4.set(GEOM, surface);
     		//four
     		store.insert(feature4);
     		store.finishEditing();
     		//Are all four inside?
     		assertEquals(4,store.getFeatureCount());
     		store.dispose();
+    	}
     	public void testRemoveFeatures() throws DataException, ValidateDataParametersException, CreateGeometryException{
     		FeatureStore store = createEditableFeatureStore();
     		store.edit();
     		EditableFeature feature = store.createNewFeature().getEditable();
     		feature.set(ID, "0");
     		feature.set(GEOM, geomManager.createPoint(0, 0, SUBTYPES.GEOM2D));
     		// One
     		store.insert(feature);
     		EditableFeature feature2 = store.createNewFeature().getEditable();
     		feature2.set(ID, "1");
     		Curve curve =  geomManager.createCurve(Geometry.SUBTYPES.GEOM2D);
     		curve.addVertex(0,0);
     		curve.addVertex(1,0);
     		curve.addVertex(1,1);
     		curve.addVertex(0,1);
     		curve.addVertex(0,0);
     		feature2.set(GEOM, curve);
     		// Two
     		store.insert(feature2);
     		EditableFeature feature3 = store.createNewFeature().getEditable();
     		feature3.set(ID, "2");
     		Surface surface =  geomManager.createSurface(Geometry.SUBTYPES.GEOM2D);
     		surface.addVertex(0,0);
     		surface.addVertex(1,0);
     		surface.addVertex(1,1);
     		surface.addVertex(0,1);
     		surface.addVertex(0,0);
     		feature3.set(GEOM, surface);
     		//Three
     		store.insert(feature3);
     		Envelope envelope = store.getEnvelope();
     		assertNotNull(envelope);
     		store.finishEditing();
     		// Editing other time and remove the second one
     		store.edit();
     		FeatureSet featureSet = store.getFeatureSet();
     		DisposableIterator it = featureSet.fastIterator();
     		//Count the features in the set
     		int i=1;
     		Feature addedFeature2 = null;
     		while (it.hasNext()){
     			Feature feat = (Feature)it.next();
     			if (i == 2){
     				addedFeature2 = feat;
+    			}
     			i++;
+    		}
     		store.delete(addedFeature2);
     		store.finishEditing();
     		//Are two inside?
     		assertEquals(2,store.getFeatureCount());
     		store.dispose();
+    	}
     	public void testUpdateFeatures() throws DataException, ValidateDataParametersException, CreateGeometryException{
     		FeatureStore store = createEditableFeatureStore();
     		store.edit();
     		EditableFeature feature = store.createNewFeature().getEditable();
     		feature.set(ID, "0");
     		feature.set(GEOM, geomManager.createPoint(0, 0, SUBTYPES.GEOM2D));
     		feature.set(LABEL, "Hi");
     		store.insert(feature);
     		store.finishEditing();
     		// Editing other time and update
     		store.edit();
     		FeatureSet featureSet = store.getFeatureSet();
     		DisposableIterator it = featureSet.fastIterator();
     		EditableFeature editableFeature = null;
     		while (it.hasNext()){
     			Feature feat = (Feature)it.next();
     			editableFeature = feat.getEditable();
     			editableFeature.set(LABEL, "Bye");
+    		}
     		store.update(editableFeature);
     		store.finishEditing();
     		//Check the value
     		featureSet = store.getFeatureSet();
     		it = featureSet.fastIterator();
     		while (it.hasNext()){
     			Feature feat = (Feature)it.next();
     			assertEquals("Bye", feat.get(LABEL));
+    		}
     		store.dispose();
+    	}
+    }

         public Envelope getDefaultEnvelope() {
             Envelope envelope = this.data.getDefaultEnvelope();
             if( envelope == null ) {
                 int i = this.data.getType().getDefaultGeometryAttributeIndex();
                 if( i<0 ) {
                     return null;
+                }
                 Geometry geom = this.getDefaultGeometry();
                 if( geom!=null ) {
                     envelope = geom.getEnvelope();
-...
         	Geometry geom = this.data.getDefaultGeometry();
             if( geom == null ) {
                 int i = this.data.getType().getDefaultGeometryAttributeIndex();
                 if( i<0 ) {
                     return null;
+                }
                 Object x = this.get(i);
                 if( x instanceof Geometry ) {
                     geom = (Geometry) x;

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/store/memory/MemoryStoreParameters.java
88	88
89	89	}
90	90	}
91
	91
	92	@Override
	93	public String getProviderName() {
	94	return MemoryStoreProvider.NAME;
	95	}
	96
	97
92	98	public String getDataStoreName() {
93	99	return MemoryStoreProvider.NAME;
94	100	}

Also available in: Unified diff