/ - Diff - Application: gvSIG desktop - gvSIG

     import org.gvsig.fmap.dal.feature.EditableFeatureType;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider.FeatureTypeChanged;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.fmap.dal.store.h2.TestUtils;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
     import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.db/org.gvsig.fmap.dal.db.jdbc/src/main/java/org/gvsig/fmap/dal/store/jdbc/JDBCStoreProviderWriter.java
37	37	import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
38	38	import org.gvsig.fmap.dal.feature.FeatureRules;
39	39	import org.gvsig.fmap.dal.feature.FeatureType;
	40	import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
40	41	import org.gvsig.fmap.dal.feature.exception.PerformEditingException;
41	42	import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
42	43	import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureReference;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;
     import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;
-...
                 Iterator<FeatureReferenceProviderServices> deleteds,
                 Iterator<FeatureProvider> inserteds,
                 Iterator<FeatureProvider> updateds,
                 Iterator<FeatureStoreProvider.FeatureTypeChanged> featureTypesChanged) {
                 Iterator<FeatureTypeChanged> featureTypesChanged) {
             super(helper);
             this.deleteds = deleteds;
             this.inserteds = inserteds;
-...
             this.table = table;
             this.featureType = featureType;
             if (featureTypesChanged.hasNext()) {
                 FeatureStoreProvider.FeatureTypeChanged item = featureTypesChanged.next();
                 FeatureTypeChanged item = featureTypesChanged.next();
                 this.featureTypeSource = item.getSource();
                 this.featureTypeTarget = item.getTarget();
                 typeChanged = true;

      */
     package org.gvsig.fmap.dal;
     import org.gvsig.tools.observer.Notification;
     /**
      * This interface represents a notification produced by a DataStore.
+     *
-...
      * of constants that represent the types of notifications that a DataStore
      * can produce.
      */
     public interface DataStoreNotification {
     public interface DataStoreNotification extends Notification {
     	/** Complex notification for special situations */
     	public static final String COMPLEX_NOTIFICATION = "complex_notification";
-...
     	 */
     	public DataStore getSource();
     	/**
     	 * Returns the type of this notification, represented by one of the constants defined in this interface.
     	 * @return a String containing this notification's type
     	 */
     	public String getType();
+    }

     import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;
     import org.gvsig.fmap.dal.feature.DataProfile;
     import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
     import org.gvsig.tools.observer.Observer;
     import org.gvsig.tools.resourcesstorage.ResourcesStorage;
     /**
-...
         public static final String DAL_PREFERRED_COLUMNS = "DAL.Preferred.Columns";
         public static final String DAL_USE_LABELS = "DAL.useLabels";
         public static final int USE_LABELS_YES = 0;
         public static final int USE_LABELS_NO = 1;
         public static final int USE_LABELS_BOTH = 2;
-...
         public DALExpressionBuilder createDALExpressionBuilder();
         public boolean isTheOldRasterRegistered();
         public void addStoreObserver(Observer observer);
         public void removeStoreObserver(Observer observer);
+    }

      */
     package org.gvsig.fmap.dal.feature;
     import java.util.Iterator;
     import org.gvsig.fmap.dal.DataSet;
     import org.gvsig.fmap.dal.DataStoreNotification;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.tools.undo.command.Command;
     public interface FeatureStoreNotification extends DataStoreNotification {
-...
     	public static final String AFTER_INSERT = "after_Insert_Feature";
     	public static final String LOAD_FINISHED = "Load_Finished";
     	public static final String TRANSFORM_CHANGE = "Transform_Change";
         /**
-...
     	public Command getCommand();
     	public EditableFeatureType getFeatureType();
       public boolean isSelectionCompromised();
       public Iterator<FeatureReference> getDeletedsFeatures();
       public Iterator<Feature> getInsertedsFeatures();
       public Iterator<Feature> getUpdatedsFeatures();
       public Iterator<FeatureTypeChanged> getChangedsFeatureTypes();
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.api/src/main/java/org/gvsig/fmap/dal/feature/FeatureCache.java
54	54	* Add a set of features contained in a envelope for a concrete scale.
55	55	* @param featureSet
56	56	* The feature set retrieved from the server.
	57	* @param featureStore
57	58	* @throws DataException
58	59	*/
59	60	public void addFeatures(FeatureSet featureSet, FeatureStore featureStore) throws DataException;

     package org.gvsig.fmap.dal.feature;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.tools.persistence.Persistent;
     /**
      * Represents a Feature validation rule. These rules are used to
-...
      * del store.
+     *
      */
     public interface FeatureRule {
     public interface FeatureRule extends Persistent{
     	/**
     	 * Returns the rule name

      * </ul>
      */
     public interface FeatureType extends DynClass, DynStruct_v2, UnmodifiableBasicList<FeatureAttributeDescriptor> {
         public interface FeatureTypeChanged {
           FeatureType getSource();
           FeatureType getTarget();
+        }
         public static final Predicate<FeatureAttributeDescriptor> BASIC_TYPES_FILTER = new Predicate<FeatureAttributeDescriptor>() {
             @Override
             public boolean test(FeatureAttributeDescriptor attrdesc) {
-...
                 return true;
+            }
         };
         /**
          * Returns a new copy of this FeatureType
+         *

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.dal.feature.rule;
     import org.gvsig.fmap.dal.feature.FeatureRule;
     /**
+     *
      * Empty interface to tag the FeatureRule that check the
      * compliance of mandatory attributes. This is used to
      * check if there is already a rule that checks this
      * in a certain feature type.
+     *
      * @author jldominguez
+     *
      */
     public interface CheckMandatoryAttributesRule extends FeatureRule {
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.dal.feature.rule;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.AbstractFeatureRule;
     import org.gvsig.fmap.dal.feature.EditableFeature;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.Geometry;
     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.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Surface;
     public class FeatureRulePolygon extends AbstractFeatureRule {
     	private static GeometryManager geomManager = GeometryLocator.getGeometryManager();
     	public FeatureRulePolygon() {
     		super("RulePolygon", "Ensure orientation of geometry");
+    	}
     	public void validate(Feature feature, FeatureStore store)
     			throws DataException {
             try {
     			Geometry geom = feature.getDefaultGeometry();
     			GeneralPathX gp = new GeneralPathX();
     			gp.append(geom.getPathIterator(null, geomManager.getFlatness()), true);
     			if (gp.isClosed()) {
     				if (gp.isCCW()) {
     					gp.flip();
     					GeometryManager geomManager = GeometryLocator.getGeometryManager();
     					Surface surface = (Surface)geomManager.create(TYPES.SURFACE, SUBTYPES.GEOM2D);
     					surface.setGeneralPath(gp);
     					geom = surface;
     	        		EditableFeature editable = feature.getEditable();
     					editable.setDefaultGeometry(geom);
     					store.update(editable);
+    				}
+    	        }
     		} catch (Exception e) {
     			throw new FeatureRulePolygonException(e, store.getName());
+    		}
+    	}
     	public class FeatureRulePolygonException extends DataException {
     		/**
+    		 *
     		 */
     		private static final long serialVersionUID = -3014970171661713021L;
     		private final static String MESSAGE_FORMAT = "Can't apply rule  in store %(store)s.";
     		private final static String MESSAGE_KEY = "_FeatureRulePolygonException";
     		public FeatureRulePolygonException(Throwable cause, String store) {
     			super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);
     			this.setValue("store", store);
+    		}
+    	}
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2020 gvSIG Association.
+     *
      * 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 3
      * 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.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.fmap.dal.feature;
     import org.gvsig.expressionevaluator.Expression;
     public interface FeatureRuleExpression extends FeatureRule {
     	public void setCheckAtUpdate(boolean checkAtUpdate);
       public void setCheckAtFinishEditing(boolean checkAtFinishEditing);
       public Expression getExpression();
       public void setExpression(Expression expression);
+    }

     package org.gvsig.fmap.dal.feature;
     import java.util.Iterator;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.tools.persistence.Persistent;
     /**
      * This is a container for FeatureRules.
-...
      * the whole structure.
+     *
      */
     public interface FeatureRules extends Iterable<FeatureRule> {
     public interface FeatureRules extends Iterable<FeatureRule>, Persistent {
     	/**
     	 * Returns an object given its index.
-...
     	 * @return
     	 * 		the object found in the given index
     	 */
     	public Object get(int index);
     	public FeatureRule get(int index);
     	/**
     	 * Returns a {@link FeatureRule} given its index.
-...
     	 */
     	public boolean add(FeatureRule rule);
       public boolean add(String name, String description, boolean checkAtUpdate,
     			boolean checkAtFinishEdition, Expression expression);
     	/**
     	 * Returns the number of rules contained in this FeatureRules.
+    	 *
-...
     	 */
     	public int size();
         public boolean isEmpty();
       public boolean isEmpty();
     	/**
     	 * Clears this FeatureRules from any rules.
-...
     	 * @return
     	 * 		returns the removed rule
     	 */
     	public Object remove(int index);
     	public FeatureRule remove(int index);
     	/**
     	 * Removes the given rule from this FeatureRules.

     	public int getOIDType();
     	/**
     	 * Factory of {@link FeatureProvider}. Create a new {@link FeatureProvider} instance
     	 * valid for this Store.
     	 * Factory of {@link FeatureProvider}.
        * Create a new {@link FeatureProvider} instance valid for this Store.
+    	 *
     	 * @param {@link FeatureType} of the {@link FeatureProvider}
     	 * @param type, {@link FeatureType} of the {@link FeatureProvider}
     	 * @return
     	 * @throws DataException
     	 */
-...
     	 * as {@link FeatureType}
+    	 *
     	 * @param reference
        * @param featureType
     	 * @return
     	 * @throws DataException
     	 */
-...
     	/**
     	 * Informs that store supports write.
+    	 *
     	 * @return <true> if write is supported
     	 * @return true if write is supported
     	 */
     	public boolean allowWrite();
-...
     	 */
     	public boolean canWriteGeometry(int geometryType, int geometrySubType) throws DataException;
     	public interface FeatureTypeChanged {
     		FeatureType getSource();
     		FeatureType getTarget();
+    	}
     	/**
     	 * Perform changes on store.
+    	 *
-...
+    	 *
     	 * @return this store's total envelope (extent) or <code>null</code> if
     	 *         store not have geometry information
        * @throws org.gvsig.fmap.dal.exception.DataException
     	 */
     	public Envelope getEnvelope() throws DataException;
-...
     	 * the {@link FeatureStoreProvider#getEnvelope()} method doesn't return
     	 * the full envelope.
+    	 *
     	 * @return
     	 * <true> if it knows the real envelope.
     	 * @return true if it knows the real envelope.
     	 */
     	public boolean isKnownEnvelope();
-...
     	 * Return if the maximum number of features provided by the
     	 * provider are limited.
+    	 *
     	 * @return
     	 * <true> if there is a limit of features.
     	 * @return true if there is a limit of features.
     	 */
     	public boolean hasRetrievedFeaturesLimit();

     	 * Call this to send a notification to observers of this store
+    	 *
     	 * @param notification
        * @return
     	 */
     	public void notifyChange(String notification);
     	public FeatureStoreNotification notifyChange(String notification);
     	/**
     	 * Call this to send a notification to observers of this store
+    	 *
     	 * @param notification
        * @param data
        * @return
     	 */
     	public void notifyChange(String notification, FeatureProvider data);
     	public FeatureStoreNotification notifyChange(String notification, FeatureProvider data);
     	/**
     	 * Call this to send a notification to observers of this store
+    	 *
     	 * @param notification
        * @param storeNotification
        * @return
     	 */
     	public void notifyChange(FeatureStoreNotification storeNotification);
     	public FeatureStoreNotification notifyChange(FeatureStoreNotification storeNotification);
     	/**
     	 * Call this to send a notification to observers of this store relative to
     	 * Resources
+    	 *
     	 * @param notification
        * @param resource
        * @return
     	 */
     	public void notifyChange(String notification, Resource resource);
     	public FeatureStoreNotification notifyChange(String notification, Resource resource);
     	/**
     	 * Create a new instance of default implementation of a
-...
     	/**
     	 * Create a new instance of default implementation of a {@link FeatureProvider}
+    	 *
        * @param type
     	 * @return new {@link FeatureProvider}
     	 * @throws DataException
     	 */
-...
     	 * <strong>Note:</strong> <code>defaultType</code> must be in
     	 * <code>types</code>
+    	 *
     	 * @param list
     	 *            of all {@link FeatureType} available
     	 * @param {@link FeatureType} used in
     	 *        {@link FeatureStore#getDefaultFeatureType()}
     	 * @param types, list of all {@link FeatureType} available
        * @param defaultType, {@link FeatureType} used in {@link FeatureStore#getDefaultFeatureType()}
     	 */
     	public void setFeatureTypes(List types, FeatureType defaultType);
-...
     	public EditableFeatureType createFeatureType();
     	/**
     	 * Creates a new instance of EditableFeatureType. Uses 'id' as identifier.
     	 * Creates a new instance of EditableFeatureType.Uses 'id' as identifier.
+    	 *
        * @param id
     	 * @return
     	 */
     	public EditableFeatureType createFeatureType(String id);
-...
     	/**
     	 * Return original {@link FeatureType} of {@link FeatureStoreProvider}.
+    	 *
     	 * @param id
     	 *            of the {@link FeatureType}
     	 * @param featureTypeId, of the {@link FeatureType}
     	 * @return
     	 * @throws DataException
     	 */
     	public FeatureType getProviderFeatureType(String featureTypeId);
-...
     	 * Return default {@link FeatureType} of the store
+    	 *
     	 * @return
        * @throws org.gvsig.fmap.dal.exception.DataException
     	 */
     	public FeatureType getDefaultFeatureType() throws DataException;
             public List getFeatureTypes() throws DataException;
       public List getFeatureTypes() throws DataException;
+    }

     import java.io.File;
     import java.io.IOException;
     import java.math.BigDecimal;
     import java.math.MathContext;
     import java.math.RoundingMode;
     import java.nio.charset.Charset;
     import java.text.SimpleDateFormat;
     import java.util.ArrayList;
     import java.util.Date;
     import java.util.Iterator;
     import java.util.List;
-...
     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.FeatureType.FeatureTypeChanged;
     import org.gvsig.fmap.dal.feature.exception.AttributeNameException;
     import org.gvsig.fmap.dal.feature.exception.AttributeNameTooLongException;
     import org.gvsig.fmap.dal.feature.exception.PerformEditingException;
-...
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.tools.dataTypes.CoercionContextDecimal;
     public class DBFStoreProvider extends AbstractFeatureStoreProvider implements
             ResourceConsumer {

     package org.gvsig.expressionevaluator.impl;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.expressionevaluator.impl.symboltable.FeatureSymbolTableImpl;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;
     import org.gvsig.fmap.dal.feature.AbstractFeatureRule;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureRuleExpression;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.exception.ValidateFeaturesException;
     import org.gvsig.tools.dataTypes.DataTypeUtils;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     /**
+     *
      * @author gvSIG team
      */
     public class DefaultFeatureRuleExpression
             extends AbstractFeatureRule
             implements FeatureRuleExpression
+      {
       private Expression expression;
       private FeatureSymbolTable symbolTable;
       public DefaultFeatureRuleExpression(String name, String description, boolean checkAtUpdate,
     			boolean checkAtFinishEdition, Expression expression) {
         super(name, description, checkAtUpdate, checkAtFinishEdition);
         this.expression = expression;
         this.symbolTable = new FeatureSymbolTableImpl();
+      }
       @Override
       public void validate(Feature feature, FeatureStore featureStore) throws DataException {
         this.symbolTable.setFeature(feature);
         Object value = this.expression.execute(symbolTable);
         boolean ok = false;
         if( value!=null ) {
           if( value instanceof Boolean ) {
             ok = (Boolean)value;
           } else {
             ok = DataTypeUtils.toBoolean(value, false);
+          }
+        }
         if( ok ) {
           return;
+        }
         throw new ValidateFeaturesException(null, featureStore.getName());
+      }
       public static void selfRegister() {
+      }
       @Override
       public void loadFromState(PersistentState state) throws PersistenceException {
         this.name = state.getString("name");
         this.description = state.getString("description");
         this.checkAtFinishEdition = state.getBoolean("checkAtFinishEdition");
         this.checkAtUpdate = state.getBoolean("checkAtUpdate");
         this.expression = (Expression) state.get("expression");
         this.symbolTable = new FeatureSymbolTableImpl();
+      }
       @Override
       public void saveToState(PersistentState state) throws PersistenceException {
         state.set("name", this.name);
         state.set("description", this.description);
         state.set("checkAtFinishEdition", this.checkAtFinishEdition);
         state.set("checkAtUpdate", this.checkAtUpdate);
         state.set("expression", this.expression);
+      }
       @Override
       public void setCheckAtUpdate(boolean checkAtUpdate) {
         this.checkAtUpdate = checkAtUpdate;
+      }
       @Override
       public void setCheckAtFinishEditing(boolean checkAtFinishEditing) {
         this.checkAtFinishEdition = checkAtFinishEditing;
+      }
       @Override
       public Expression getExpression() {
         return this.expression;
+      }
       @Override
       public void setExpression(Expression expression) {
         this.expression = expression;
+      }
+    }

     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.DataStoreNotification;
     import org.gvsig.tools.observer.BaseNotification;
     import org.gvsig.tools.undo.command.Command;
     public class DefaultCoverageStoreNotification implements DataStoreNotification {
     public class DefaultCoverageStoreNotification
             extends BaseNotification
             implements DataStoreNotification
+      {
     	public DefaultCoverageStoreNotification(
     			DefaultCoverageStore defaultCoverageStore, String notification,
     			Command command) {
     		// TODO Auto-generated constructor stub
     			DefaultCoverageStore defaultCoverageStore, String notification) {
         super(notification, 2);
         this.setValue(0, defaultCoverageStore);
+    	}
     	public DefaultCoverageStoreNotification(
     			DefaultCoverageStore defaultCoverageStore, String notification) {
     		// TODO Auto-generated constructor stub
     			DefaultCoverageStore defaultCoverageStore, String notification,
     			Command command) {
         this(defaultCoverageStore, notification);
         this.setValue(1, command);
+    	}
       @Override
     	public DataStore getSource() {
     		// TODO Auto-generated method stub
     		return null;
     		return (DataStore) this.getValue(0);
+    	}
     	public String getType() {
     		// TODO Auto-generated method stub
     		return null;
+    	}
+    }

     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.raster.RasterStoreNotification;
     import org.gvsig.tools.observer.BaseNotification;
     /**
      * Implements RasterNofication
      * @author dmartinezizquierdo
+     *
      */
     public class DefaultRasterStoreNotification implements RasterStoreNotification{
     public class DefaultRasterStoreNotification
             extends BaseNotification
             implements RasterStoreNotification
+      {
         private String type;
         private DataStore source;
         protected void init(DataStore source, String type) {
             this.source = source;
             this.type = type;
+        }
         /**
          * @param source
          * @param type
          */
         public DefaultRasterStoreNotification(DataStore source, String type) {
             this.init(source, type);
             super(type, 1);
             this.setValue(0, source);
+        }
         @Override
         public DataStore getSource() {
             return source;
             return (DataStore) this.getValue(0);
+        }
         @Override
         public String getType() {
             return type;
+        }
+    }

     import java.util.ArrayList;
     import java.util.Collections;
     import java.util.HashMap;
     import java.util.HashSet;
     import java.util.List;
     import java.util.Map;
     import java.util.Objects;
     import java.util.Set;
     import java.util.UUID;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.lang3.StringUtils;
-...
     import org.gvsig.fmap.dal.DataServerExplorerPool;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.DataStoreFactory_v2_4;
     import org.gvsig.fmap.dal.DataStoreNotification;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.DataStoreProviderFactory;
     import org.gvsig.fmap.dal.DataTypes;
-...
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.fmap.dal.DatabaseWorkspaceManager.DatabaseWorkspaceListener;
     import org.gvsig.fmap.dal.feature.FeatureStoreNotification;
     import org.gvsig.tools.observer.Observer;
     @SuppressWarnings("UseSpecificCatch")
     public class DefaultDataManager
-...
         private final Map<String, DatabaseWorkspaceManager> databaseWorkspaces = new HashMap<>();
         private final Map<String,DatabaseWorkspaceListener> addDatabaseWorkspaceListeners = new HashMap<>();
         private final Set<Observer>storeObservers = new HashSet<>();
         public DefaultDataManager() {
             this.registers = new Registers();
-...
             DataStoreProvider provider = (DataStoreProvider) providerFactory.create(parameters, store);
             storeFactory.setProvider(store, provider);
             for (Observer storeObserver : storeObservers) {
               if( storeObserver!=null) {
                 store.addObserver(storeObserver);
+              }
+            }
             if( store instanceof FeatureStoreProviderServices ) {
               ((FeatureStoreProviderServices) store).notifyChange(DataStoreNotification.AFTER_OPEN);
+            }
             return store;
+        }
         @Override
         public DataStore openStore(DataStoreParameters parameters, DataStoreProvider provider) {
             String storeName = this.getStoreName(parameters);
             if( StringUtils.isEmpty(storeName) ) {
-...
+            }
             DataStore store = (DataStore) storeFactory.create(parameters, this);
             storeFactory.setProvider(store, provider);
             for (Observer storeObserver : storeObservers) {
               if( storeObserver!=null) {
                 store.addObserver(storeObserver);
+              }
+            }
             if( store instanceof FeatureStoreProviderServices ) {
               ((FeatureStoreProviderServices) store).notifyChange(DataStoreNotification.AFTER_OPEN);
+            }
             return store;
+        }
-...
         return new DefaultDALExpressionBuilder();
+      }
       @Override
       public void addStoreObserver(Observer observer) {
         this.storeObservers.add(observer);
+      }
       @Override
       public void removeStoreObserver(Observer observer) {
         this.storeObservers.remove(observer);
+      }
+    }

     package org.gvsig.fmap.dal.feature.impl;
     import java.util.ArrayList;
     import java.util.Iterator;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.expressionevaluator.impl.DefaultFeatureRuleExpression;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureRule;
     import org.gvsig.fmap.dal.feature.FeatureRules;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public class DefaultFeatureRules extends ArrayList<FeatureRule> implements FeatureRules {
             private final static Logger logger = LoggerFactory.getLogger(DefaultFeatureRules.class);
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = -8084546505498274121L;
             @Override
     	public boolean add(FeatureRule rule) {
     		return super.add(rule);
+    	}
       private final static Logger LOGGER = LoggerFactory.getLogger(DefaultFeatureRules.class);
             @Override
     	public FeatureRule getRule(int index) {
     		return (FeatureRule) super.get(index);
+    	}
       /**
+       *
        */
       private static final long serialVersionUID = -8084546505498274121L;
             @Override
     	public boolean remove(FeatureRule rule) {
     		return super.remove(rule);
+    	}
       @Override
       public boolean add(FeatureRule rule) {
         return super.add(rule);
+      }
             @Override
     	public FeatureRules getCopy() {
     		DefaultFeatureRules copy = new DefaultFeatureRules();
     		copy.addAll(this);
     		return copy;
+    	}
       @Override
       public boolean add(String name, String description, boolean checkAtUpdate, boolean checkAtFinishEdition, Expression expression) {
         FeatureRule rule = new DefaultFeatureRuleExpression(name, description, checkAtUpdate, checkAtFinishEdition, expression);
         return this.add(rule);
+      }
             /**
              * @deprecated use validate(Feature feature, int mode)
              * @param feature
              * @throws DataException
              */
     	public void validate(Feature feature) throws DataException {
                 logger.warn("Calling deprecated method validate without mode.");
                 FeatureStore store = ((DefaultFeature)feature).getStore();
                 for( FeatureRule rule : this ) {
                     rule.validate(feature, store);
+                }
       @Override
       public FeatureRule getRule(int index) {
         return (FeatureRule) super.get(index);
+      }
+    	}
       @Override
       public boolean remove(FeatureRule rule) {
         return super.remove(rule);
+      }
     	public void validate(Feature feature, int mode) throws DataException {
                 FeatureStore store = ((DefaultFeature)feature).getStore();
                 for( FeatureRule rule : this ) {
                     if( rule.checkAtFinishEditing() && mode == Feature.FINISH_EDITING ) {
                         rule.validate(feature, store);
+                    }
                     if( rule.checkAtUpdate() && mode == Feature.UPDATE ) {
                         rule.validate(feature, store);
+                    }
+                }
       @Override
       public FeatureRules getCopy() {
         DefaultFeatureRules copy = new DefaultFeatureRules();
         copy.addAll(this);
         return copy;
+      }
+    	}
     //        /**
     //         * @deprecated use validate(Feature feature, int mode)
     //         * @param feature
     //         * @throws DataException
     //         */
     //	public void validate(Feature feature) throws DataException {
     //            logger.warn("Calling deprecated method validate without mode.");
     //            FeatureStore store = ((DefaultFeature)feature).getStore();
     //            for( FeatureRule rule : this ) {
     //                rule.validate(feature, store);
     //            }
     //
     //	}
       public void validate(Feature feature, int mode) throws DataException {
         FeatureStore store = ((DefaultFeature) feature).getStore();
         for (FeatureRule rule : this) {
           if (rule.checkAtFinishEditing() && mode == Feature.FINISH_EDITING) {
             rule.validate(feature, store);
+          }
           if (rule.checkAtUpdate() && mode == Feature.UPDATE) {
             rule.validate(feature, store);
+          }
+        }
+      }
       public static void selfRegister() {
+      }
       @Override
       public void saveToState(PersistentState state) throws PersistenceException {
         state.set("rules", this.iterator());
+      }
       @Override
       public void loadFromState(PersistentState state) throws PersistenceException {
         this.clear();
         Iterator<FeatureRule> it = state.getIterator("rules");
         while (it.hasNext()) {
           FeatureRule rule = it.next();
           this.add(rule);
+        }
+      }
+    }

     import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;
     import org.gvsig.fmap.dal.feature.FeatureStoreTimeSupport;
     import org.gvsig.fmap.dal.feature.FeatureStoreTransform;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.fmap.dal.feature.exception.AlreadyEditingException;
     import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;
     import org.gvsig.fmap.dal.feature.exception.CreateFeatureException;
-...
                     LOGGER.warn("Opening a store in editing/append mode ("+this.getFullName()+").",ex);
+                }
+            }
             this.notifyChange(DataStoreNotification.BEFORE_OPEN);
             if( this.notifyChange(DataStoreNotification.BEFORE_OPEN).isCanceled() ) {
               return;
+            }
             this.provider.open();
             this.notifyChange(DataStoreNotification.AFTER_OPEN);
+        }
-...
             if (this.mode != MODE_QUERY) {
                 throw new IllegalStateException();
+            }
             this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH);
             if( this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH).isCanceled() ) {
               return;
+            }
             if( state.isBroken() ) {
                 this.load(state);
             } else {
-...
                     LOGGER.warn("Clossing a store in editing/append mode ("+this.getFullName()+").",ex);
+                }
+            }
             this.notifyChange(DataStoreNotification.BEFORE_CLOSE);
             if( this.notifyChange(DataStoreNotification.BEFORE_CLOSE).isCanceled() ) {
               return;
+            }
             this.featureCount = null;
             this.provider.close();
             this.notifyChange(DataStoreNotification.AFTER_CLOSE);
-...
                     LOGGER.warn("Dispossing a store in editing/append mode ("+this.getFullName()+").",ex);
+                }
+            }
             this.notifyChange(DataStoreNotification.BEFORE_DISPOSE);
             if( this.notifyChange(DataStoreNotification.BEFORE_DISPOSE).isCanceled() ) {
               return;
+            }
             this.disposeIndexes();
             if( this.provider!=null ) {
                 this.provider.dispose();
-...
         //
         @Override
         public void notifyChange(FeatureStoreNotification storeNotification) {
             try {
                 delegateObservable.notifyObservers(storeNotification);
             } catch (Throwable ex) {
                 LOGGER.warn("Problems notifying changes in the store '"+this.getName()+" ("+storeNotification.getType()+").",ex);
         public FeatureStoreNotification notifyChange(FeatureStoreNotification storeNotification) {
             if (delegateObservable != null) {
               try {
                   delegateObservable.notifyObservers(storeNotification);
               } catch (Throwable ex) {
                   LOGGER.warn("Problems notifying changes in the store '"+this.getName()+" ("+storeNotification.getType()+").",ex);
+              }
+            }
             return storeNotification;
+        }
         @Override
         public void notifyChange(String notification) {
             if (delegateObservable != null) {
                 notifyChange(new DefaultFeatureStoreNotification(this, notification));
+            }
         public FeatureStoreNotification notifyChange(String notification) {
           return notifyChange(new DefaultFeatureStoreNotification(this, notification));
+        }
         public FeatureStoreNotification notifyChange(String notification,
           Iterator<FeatureReference> deleteds,
           Iterator<Feature> inserteds,
           Iterator<Feature> updateds,
           Iterator<FeatureTypeChanged> featureTypesChanged,
           boolean isSelectionCompromised) {
             return notifyChange(new DefaultFeatureStoreNotification(this, notification,
                 deleteds, inserteds, updateds, featureTypesChanged, isSelectionCompromised));
+        }
         @Override
         public void notifyChange(String notification, FeatureProvider data) {
         public FeatureStoreNotification notifyChange(String notification, FeatureProvider data) {
             Feature f = null;
             try {
                 f = createFeature(data);
             } catch (Throwable ex) {
                 LOGGER.warn("Problems creating a feature to notifying changes in the store '"+this.getName()+" ("+notification+").",ex);
             if( data !=null ) {
               try {
                   f = createFeature(data);
               } catch (Throwable ex) {
                   LOGGER.warn("Problems creating a feature to notifying changes in the store '"+this.getName()+" ("+notification+").",ex);
+              }
+            }
             notifyChange(notification, f);
             return notifyChange(notification, f);
+        }
         public void notifyChange(String notification, Feature feature) {
             notifyChange(new DefaultFeatureStoreNotification(this, notification,
         public FeatureStoreNotification notifyChange(String notification, Feature feature) {
             return notifyChange(new DefaultFeatureStoreNotification(this, notification,
                 feature));
+        }
         public void notifyChange(String notification, Command command) {
             notifyChange(new DefaultFeatureStoreNotification(this, notification,
         public FeatureStoreNotification notifyChange(String notification, Command command) {
             return notifyChange(new DefaultFeatureStoreNotification(this, notification,
                 command));
+        }
         public void notifyChange(String notification, EditableFeatureType type) {
             notifyChange(new DefaultFeatureStoreNotification(this, notification,
         public FeatureStoreNotification notifyChange(String notification, EditableFeatureType type) {
             return notifyChange(new DefaultFeatureStoreNotification(this, notification,
                 type));
+        }
         @Override
         public void notifyChange(String notification, Resource resource) {
             notifyChange(new DefaultFeatureStoreNotification(this,
         public FeatureStoreNotification notifyChange(String notification, Resource resource) {
             return notifyChange(new DefaultFeatureStoreNotification(this,
                 DataStoreNotification.RESOURCE_CHANGED));
+        }
-...
                     if (!this.transforms.isEmpty()) {
                         throw new IllegalStateException(this.getName());
+                    }
                     notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);
                     if( notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING).isCanceled() ) {
                       return;
+                    }
                     invalidateIndexes();
                     featureManager = new FeatureManager();
                     featureTypeManager = new FeatureTypeManager(this);
-...
                     if (!this.transforms.isEmpty()) {
                         throw new IllegalStateException(this.getName());
+                    }
                     notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);
                     if( notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING).isCanceled() ) {
                       return;
+                    }
                     invalidateIndexes();
                     this.provider.beginAppend();
                     this.mode = MODE_APPEND;
-...
                     throw new NullFeatureTypeException(getName());
+                }
                 if (mode == MODE_QUERY && type.hasOnlyMetadataChanges(this.defaultFeatureType)) {
                     notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type);
                     if( notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type).isCanceled() ) {
                       return;
+                    }
                     FeatureType theType = type.getNotEditableCopy();
                     if( defaultFeatureType.getId().equals(theType.getId()) ) {
                         defaultFeatureType = theType;
-...
                     throw new NeedEditingModeException(this.getName());
+                }
                 // FIXME: Comprobar que es un featureType aceptable.
                 notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type);
                 if( notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type).isCanceled() ) {
                   return;
+                }
                 newVersionOfUpdate();
                 FeatureType oldt = type.getSource().getCopy();
-...
                 if (feature instanceof EditableFeature) {
                     throw new StoreDeleteEditableFeatureException(getName());
+                }
                 notifyChange(FeatureStoreNotification.BEFORE_DELETE, feature);
                 if( notifyChange(FeatureStoreNotification.BEFORE_DELETE, feature).isCanceled() ) {
                   return;
+                }
                 //Update the featureManager and the spatialManager
                 featureManager.delete(feature.getReference());
-...
                     if (feature.getSource() != null) {
                         throw new NoNewFeatureInsertException(this.getName());
+                    }
                     if( notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature).isCanceled() ) {
                       return;
+                    }
                     this.featureCount = null;
                     notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);
                     feature.validate(Feature.UPDATE);
                     provider.append(((DefaultEditableFeature) feature).getData());
                     hasStrongChanges = true;
-...
                     if (feature.getSource() != null) {
                         throw new NoNewFeatureInsertException(this.getName());
+                    }
                     feature.validate(Feature.UPDATE);
                     commands.insert(feature);
+                }
             } catch (Exception e) {
-...
             waitForIndexes();
             notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);
             if( notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature).isCanceled() ) {
               return;
+            }
             newVersionOfUpdate();
             if ((lastChangedFeature == null)
                 || (lastChangedFeature.getSource() != feature.getSource())) {
-...
             try {
                 checkInEditingMode();
                 checkIsOwnFeature(feature);
                 notifyChange(FeatureStoreNotification.BEFORE_UPDATE, feature);
                 if( notifyChange(FeatureStoreNotification.BEFORE_UPDATE, feature).isCanceled() ) {
                   return;
+                }
                 newVersionOfUpdate();
                 if ((lastChangedFeature == null)
                     || (lastChangedFeature.getSource() != feature.getSource())) {
-...
             } catch (NeedEditingModeException ex) {
                 throw new RedoException(redo, ex);
+            }
             notifyChange(FeatureStoreNotification.BEFORE_REDO, redo);
             if( notifyChange(FeatureStoreNotification.BEFORE_REDO, redo).isCanceled() ) {
               return;
+            }
             newVersionOfUpdate();
             commands.redo();
             hasStrongChanges = true;
-...
             } catch (NeedEditingModeException ex) {
                 throw new UndoException(undo, ex);
+            }
             notifyChange(FeatureStoreNotification.BEFORE_UNDO, undo);
             if( notifyChange(FeatureStoreNotification.BEFORE_UNDO, undo).isCanceled() ) {
               return;
+            }
             newVersionOfUpdate();
             commands.undo();
             hasStrongChanges = true;
-...
                     throw new NeedEditingModeException(this.getName());
                 case MODE_APPEND:
                     notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING);
                     if( notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING).isCanceled() ) {
                       return;
+                    }
                     provider.abortAppend();
                     exitEditingMode();
                     ((FeatureSelection) this.getSelection()).deselectAll();
-...
                     if (this.selection instanceof FeatureReferenceSelection) {
                         clearSelection = this.hasInserts;
+                    }
                     notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING);
                     if( notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING).isCanceled() ) {
                       return;
+                    }
                     exitEditingMode();
                     if (clearSelection) {
                         ((FeatureSelection) this.getSelection()).deselectAll();
-...
                     if( selection!=null ) {
                         selection = null;
+                    }
                     notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);
                     if( notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING).isCanceled() ) {
                       return;
+                    }
                     saveDALFile();
                     provider.endAppend();
                     exitEditingMode();
-...
                     if (hasStrongChanges && !this.allowWrite()) {
                         throw new WriteNotAllowedException(getName());
+                    }
                     if( notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING,
                             featureManager.getDeleted(),
                             featureManager.getInsertedFeatures(),
                             featureManager.getUpdatedFeatures(),
                             featureTypeManager.getFeatureTypesChanged().iterator(),
                             featureManager.isSelectionCompromised()).isCanceled() ) {
                       return;
+                    }
                     saveDALFile();
                     if(featureManager.isSelectionCompromised() && selection!=null ) {
                         selection = null;
+                    }
                     notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);
                     if (hasStrongChanges) {
                         validateFeatures(Feature.FINISH_EDITING);
-...
+            }
+        }
         private List<FeatureStoreProvider.FeatureTypeChanged> removeCalculatedAttributes(List<FeatureStoreProvider.FeatureTypeChanged> ftypes) {
         private List<FeatureTypeChanged> removeCalculatedAttributes(List<FeatureTypeChanged> ftypes) {
             // FIXME: Falta por implementar
     //        for (FeatureStoreProvider.FeatureTypeChanged ftype : ftypes) {
     //            EditableFeatureType target = (EditableFeatureType) ftype.getTarget();

     import org.gvsig.fmap.dal.feature.FeatureReference;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider.FeatureTypeChanged;
     public interface EditingManager {
-...
         public boolean isSelectionCompromised();
         public Iterator<FeatureProvider> getDeletedFeatures();
         public Iterator<FeatureReference> getDeletedFeatures();
         public Iterator<FeatureProvider> getInsertedFeatures();
         public Iterator<FeatureProvider> getUpdatedFeatures();

      */
     package org.gvsig.fmap.dal.feature.impl;
     import java.util.Iterator;
     import org.gvsig.fmap.dal.DataSet;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.feature.EditableFeatureType;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureIndex;
     import org.gvsig.fmap.dal.feature.FeatureReference;
     import org.gvsig.fmap.dal.feature.FeatureStoreNotification;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.FeatureType.FeatureTypeChanged;
     import org.gvsig.tools.observer.BaseNotification;
     import org.gvsig.tools.undo.command.Command;
     public class DefaultFeatureStoreNotification implements
     		FeatureStoreNotification {
     	private Feature feature = null;
     	private DataSet collectionResult = null;
     	private boolean loadCollectionSucefully = false;
     	private Exception exceptionLoading = null;
     	private Command command = null;
     	private EditableFeatureType featureType = null;
     	private String type;
     	private DataStore source;
         private FeatureIndex index;
     public class DefaultFeatureStoreNotification
             extends BaseNotification
             implements FeatureStoreNotification {

Application: gvSIG desktop

Revision 44871