/ - Diff - Application: gvSIG desktop - gvSIG

         public FeatureSelection createMemoryFeatureSelection() throws DataException {
             return null;
+        }
         @Override
         public Feature getOriginalFeature(FeatureReference id) {
             return null;
+        }
         @Override
         public Feature getOriginalFeature(Feature feature) {
             return null;
+        }
         @Override
         public boolean isFeatureModified(FeatureReference id){
             return false;
+        }
         @Override
         public boolean isFeatureModified(Feature feature){
             return false;
+        }
+    }

          * @return true when support references.
          */
         public boolean supportReferences();
         public Feature getOriginalFeature(FeatureReference id);
         public Feature getOriginalFeature(Feature feature);
         public boolean isFeatureModified(FeatureReference id);
         public boolean isFeatureModified(Feature feature);
+    }

         private final Map<FeatureReference, Integer> added;
         private final Map<FeatureReference, Integer> addedAndDeleted;
         private final Map<FeatureReference, Integer> modifiedFromOriginal;
         private final Map<FeatureReference, Integer> original;
         public FeatureManager() {
             deltaSize = 0;
-...
             added = new LinkedHashMap<>();
             addedAndDeleted = new LinkedHashMap<>();
             modifiedFromOriginal = new HashMap<>();
             original = new HashMap<>();
+        }
         /**
-...
          * @return The deleted feature or null if the feature had not been edited or
          * previously added in the editing session
          */
         public Feature delete(FeatureReference id) {
         public Feature delete(Feature feature) {
             FeatureReference id = feature.getReference();
             if(!original.containsKey(id)){
                 int n = expansionAdapter.addObject(feature);
                 original.put(id, n);
+            }
             deleted.add(id);
             Integer num = added.remove(id);
             Feature feature = null;
             Feature previousFeature = null;
             if (num == null || num == -1) {
                 num = modifiedFromOriginal.remove(id);
                 if (num != null) {
                     feature = (Feature) expansionAdapter.getObject(num);
                     previousFeature = (Feature) expansionAdapter.getObject(num);
+                }
                 // if num is null here, method returns null
             } else {
                 feature = (Feature) expansionAdapter.getObject(num);
                 previousFeature = (Feature) expansionAdapter.getObject(num);
                 addedAndDeleted.put(id, num);
+            }
             deltaSize--;
             return feature;
             return previousFeature;
+        }
         public void add(Feature feature) {
             FeatureReference id = feature.getReference();
             if(!original.containsKey(id)){
                 original.put(id, null);
+            }
             int pos = expansionAdapter.addObject(feature);
             added.put(feature.getReference(), pos);
             deleted.remove(feature.getReference());
-...
             //        Si no existe feature con ese id... ? retorna null ?
             //        en EditedDefaultIterator se hace uso de ese comportamiento.
             //
             boolean isNewFeature = false;
             Integer intNum = (added.get(id));
             if (intNum == null) {
                 intNum = (modifiedFromOriginal.get(id));
-...
                         return null;
+                    }
+                }
             } else {
                 isNewFeature = true;
+            }
             int num = intNum;
             if (num == -1) {
-...
             if (featureType == null) {
                 featureType = store.getDefaultFeatureType();
+            }
             return new DefaultFeature(featureType, feature);
             DefaultFeature feat = new DefaultFeature(featureType, feature);
             feat.getData().setNew(isNewFeature);
             return feat;
+        }
         public int update(Feature feature, Feature oldFeature) {
             FeatureReference id = feature.getReference();
             if(!original.containsKey(id)){
                 int n = expansionAdapter.addObject(oldFeature);
                 original.put(id, n);
+            }
             int oldNum = -1;
             int num = expansionAdapter.addObject(feature);
             FeatureReference id = feature.getReference();
             if (added.containsKey(id)) {
                 oldNum = (added.get(id));
                 added.put(id, num);
-...
                 while (iter.hasNext()) {
                     pos++;
                     feature = (Feature) iter.next();
                     if ( !deleted.contains(feature.getReference()) &&
                     if ( feature != null &&
                          !deleted.contains(feature.getReference()) &&
                          modifiedFromOriginal.containsValue(pos)) {
                         hasnext = true;
                         break;
-...
             //Only deleted features can change order, as added features are added at the end.
             return deleted.size() > 0;
+        }
         public Feature getOriginal(FeatureReference id){
             Integer n = original.get(id);
             if(n == null){
                 return null;
+            }
             return (Feature) this.expansionAdapter.getObject(n);
+        }
         public boolean isFeatureModified(FeatureReference id) {
             return original.containsKey(id);
+        }
+    }

         @Override
         public void delete(Feature feature) {
             this.featureManager.delete(feature.getReference());
             this.featureManager.delete(feature);
             this.spatialManager.deleteFeature(feature);
+        }
         @Override
         public void delete(FeatureReference featureReference) {
             // ????????
             this.featureManager.delete(featureReference);
+        }
     //    @Override
     //    public void delete(FeatureReference featureReference) {
     //        // ????????
     //        this.featureManager.delete(featureReference);
     //
     //    }
         @Override
         public void add(Feature newFeature) {

+                }
                 //Update the featureManager and the spatialManager
                 featureManager.delete(feature.getReference());
                 featureManager.delete(feature);
                 spatialManager.deleteFeature(feature);
                 newVersionOfUpdate();
-...
             return this.propertiesSupportHelper.getProperties();
+        }
         @Override
         public Feature getOriginalFeature(FeatureReference id){
             if(this.featureManager == null){
                 return null;
+            }
             return featureManager.getOriginal(id);
+        }
         @Override
         public Feature getOriginalFeature(Feature feature){
             if(feature == null){
                 return null;
+            }
             return getOriginalFeature(feature.getReference());
+        }
         @Override
         public boolean isFeatureModified(FeatureReference id){
             if(this.featureManager == null){
                 return false;
+            }
             return featureManager.isFeatureModified(id);
+        }
         @Override
         public boolean isFeatureModified(Feature feature){
             if(feature == null){
                 return false;
+            }
             return isFeatureModified(feature.getReference());
+        }
+    }

         public void delete(Feature feature);
         public void delete(FeatureReference featureReference);
     //    public void delete(FeatureReference featureReference);
         public void add(Feature newFeature);

Application: gvSIG desktop

Revision 45521