/branches/v2_0_0_prep/libraries/libFMap_dal/src/org/gvsig/fmap/dal/feature/impl/DefaultFeatureSelection.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 33378 branches/v2_0_0_prep/libraries/libFMap_dal/src/org/gvsig/fmap/dal/feature/impl/DefaultFeatureSelection.java

     import org.gvsig.tools.persistence.PersistenceManager;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.visitor.VisitCanceledException;
     import org.gvsig.tools.visitor.Visitor;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
     /**
      * Default implementation of the FeatureSelection interface. Internally, only
      * FeatureReference values are stored.
+     *
+     *
      * This implementation performs better if used with the selection related
      * methods: select, deselect and isSelected ones.
+     *
+     *
      * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
      */
     public class DefaultFeatureSelection extends DefaultFeatureReferenceSelection
             implements FeatureSelection {
     		implements FeatureSelection {
         private static final Logger LOGGER = LoggerFactory
                 .getLogger(DefaultFeatureSelection.class);
     	private static final Logger LOG = LoggerFactory
     			.getLogger(DefaultFeatureSelection.class);
         private Map featureTypeCounts = new HashMap(1);
     	private Map featureTypeCounts = new HashMap(1);
         /**
          * Creates a DefaultFeatureSelection, with a FeatureStore.
+         *
          * @param featureStore
          *            the FeatureStore to load Features from
          * @throws DataException
          *             if there is an error while getting the total number of
          *             Features of the Store.
          * @see AbstractSetBasedDataSelection#DefaultSelection(int)
          */
         public DefaultFeatureSelection(DefaultFeatureStore featureStore)
                 throws DataException {
             super(featureStore);
+        }
     	/**
     	 * Creates a DefaultFeatureSelection, with a FeatureStore.
+    	 *
     	 * @param featureStore
     	 *            the FeatureStore to load Features from
     	 * @throws DataException
     	 *             if there is an error while getting the total number of
     	 *             Features of the Store.
     	 * @see AbstractSetBasedDataSelection#DefaultSelection(int)
     	 */
     	public DefaultFeatureSelection(DefaultFeatureStore featureStore)
     			throws DataException {
     		super(featureStore);
+    	}
         /**
          * Creates a new Selection with the total size of Features from which the
          * selection will be performed.
+         *
          * @param featureStore
          *            the FeatureStore of the selected FeatureReferences
          * @param helper
          *            to get some information of the Store
          * @throws DataException
          *             if there is an error while getting the total number of
          *             Features of the Store.
          */
         public DefaultFeatureSelection(FeatureStore featureStore,
                 FeatureSelectionHelper helper) throws DataException {
             super(featureStore, helper);
+        }
     	/**
     	 * Creates a new Selection with the total size of Features from which the
     	 * selection will be performed.
+    	 *
     	 * @param featureStore
     	 *            the FeatureStore of the selected FeatureReferences
     	 * @param helper
     	 *            to get some information of the Store
     	 * @throws DataException
     	 *             if there is an error while getting the total number of
     	 *             Features of the Store.
     	 */
     	public DefaultFeatureSelection(FeatureStore featureStore,
     			FeatureSelectionHelper helper) throws DataException {
     		super(featureStore, helper);
+    	}
     	/**
     	 * Constructor used by the persistence manager. Don't use directly. After to
-...
     		super();
+    	}
         public boolean select(Feature feature) {
             return select(feature, true);
+        }
     	public boolean select(Feature feature) {
     		return select(feature, true);
+    	}
         /**
          * @see #select(Feature)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean select(Feature feature, boolean undoable) {
             // TODO: should we check if the feature is from the same FeatureStore??
             if (feature == null) {
                 return false;
+            }
     	/**
     	 * @see #select(Feature)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean select(Feature feature, boolean undoable) {
     		// TODO: should we check if the feature is from the same FeatureStore??
     		if (feature == null) {
     			return false;
+    		}
     //        LOGGER.debug("Selected feature: {}", feature);
     		// LOGGER.debug("Selected feature: {}", feature);
             if (isReversed()) {
                 removeFeatureTypeCount(feature.getType());
             } else {
                 addFeatureTypeCount(feature.getType());
+            }
             return select(feature.getReference(), undoable);
+        }
     		if (isReversed()) {
     			removeFeatureTypeCount(feature.getType());
     		} else {
     			addFeatureTypeCount(feature.getType());
+    		}
     		return select(feature.getReference(), undoable);
+    	}
         public boolean select(FeatureSet features) throws DataException {
             return select(features, true);
+        }
     	public boolean select(FeatureSet features) throws DataException {
     		return select(features, true);
+    	}
         /**
          * @see #select(FeatureSet)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean select(FeatureSet features, boolean undoable)
                 throws DataException {
             boolean change = false;
             boolean inComplex = false;
             if (undoable && getFeatureStore().isEditing()
     	/**
     	 * @see #select(FeatureSet)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean select(FeatureSet features, boolean undoable)
     			throws DataException {
     		boolean change = false;
     		boolean inComplex = false;
     		if (undoable && getFeatureStore().isEditing()
     				&& !getCommands().inComplex()) {
     			inComplex = getCommands().inComplex();
     			getCommands().startComplex("_selectionSelectFeatureSet");
+            }
+    		}
             disableNotifications();
     		disableNotifications();
     		DisposableIterator iter = null;
     		try {
     			for (iter = features.fastIterator(); iter.hasNext();) {
-...
+    			}
     		} finally {
     			dispose(iter);
+            }
             enableNotifications();
             if (undoable && getFeatureStore().isEditing() && !inComplex) {
                 getCommands().endComplex();
+            }
             if (change) {
                 notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+            }
             return change;
+        }
+    		}
     		enableNotifications();
     		if (undoable && getFeatureStore().isEditing() && !inComplex) {
     			getCommands().endComplex();
+    		}
     		if (change) {
     			notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+    		}
     		return change;
+    	}
         public boolean deselect(Feature feature) {
             return deselect(feature, true);
+        }
     	public boolean deselect(Feature feature) {
     		return deselect(feature, true);
+    	}
         /**
          * @see #deselect(Feature)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean deselect(Feature feature, boolean undoable) {
             if (feature == null) {
                 return false;
+            }
     	/**
     	 * @see #deselect(Feature)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean deselect(Feature feature, boolean undoable) {
     		if (feature == null) {
     			return false;
+    		}
             LOGGER.debug("Deselected feature: {}", feature);
     		LOG.debug("Deselected feature: {}", feature);
             if (isReversed()) {
                 addFeatureTypeCount(feature.getType());
             } else {
                 removeFeatureTypeCount(feature.getType());
+            }
             return deselect(feature.getReference(), undoable);
+        }
     		if (isReversed()) {
     			addFeatureTypeCount(feature.getType());
     		} else {
     			removeFeatureTypeCount(feature.getType());
+    		}
     		return deselect(feature.getReference(), undoable);
+    	}
         public boolean deselect(FeatureSet features) throws DataException {
             return deselect(features, true);
+        }
     	public boolean deselect(FeatureSet features) throws DataException {
     		return deselect(features, true);
+    	}
         /**
          * @see #deselect(FeatureSet)
          * @param undoable
          *            if the action must be undoable
          */
         public boolean deselect(FeatureSet features, boolean undoable)
                 throws DataException {
             boolean change = false;
             if (undoable && getFeatureStore().isEditing()) {
                 getCommands().startComplex("_selectionDeselectFeatureSet");
+            }
             disableNotifications();
     	/**
     	 * @see #deselect(FeatureSet)
     	 * @param undoable
     	 *            if the action must be undoable
     	 */
     	public boolean deselect(FeatureSet features, boolean undoable)
     			throws DataException {
     		boolean change = false;
     		if (undoable && getFeatureStore().isEditing()) {
     			getCommands().startComplex("_selectionDeselectFeatureSet");
+    		}
     		disableNotifications();
     		DisposableIterator iter = null;
     		try {
     			for (iter = features.fastIterator(); iter.hasNext();) {
-...
+    			}
     		} finally {
     			dispose(iter);
+            }
             enableNotifications();
             if (undoable && getFeatureStore().isEditing()) {
                 getCommands().endComplex();
+            }
             if (change) {
                 notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+            }
             return change;
+        }
+    		}
     		enableNotifications();
     		if (undoable && getFeatureStore().isEditing()) {
     			getCommands().endComplex();
+    		}
     		if (change) {
     			notifyObservers(DataStoreNotification.SELECTION_CHANGE);
+    		}
     		return change;
+    	}
         public boolean isSelected(Feature feature) {
             if (feature == null) {
                 return false;
+            }
             return isSelected(feature.getReference());
+        }
     	public boolean isSelected(Feature feature) {
     		if (feature == null) {
     			return false;
+    		}
     		return isSelected(feature.getReference());
+    	}
         public FeatureType getDefaultFeatureType() {
             try {
                 return getFeatureStore().getDefaultFeatureType();
             } catch (DataException ex) {
                 LOGGER.error("Error getting the default feature type "
                         + "of the FeatureStore: " + getFeatureStore(), ex);
+            }
             return null;
+        }
     	public FeatureType getDefaultFeatureType() {
     		try {
     			return getFeatureStore().getDefaultFeatureType();
     		} catch (DataException ex) {
     			LOG.error("Error getting the default feature type "
     					+ "of the FeatureStore: " + getFeatureStore(), ex);
+    		}
     		return null;
+    	}
         public List getFeatureTypes() {
             // Go through the map of FeatureTypes, and return only the ones that
             // have at least a Feature.
             List types = new ArrayList();
             for (java.util.Iterator iterator = featureTypeCounts.entrySet()
     				.iterator(); iterator
                     .hasNext();) {
                 Map.Entry entry = (Entry) iterator.next();
                 FeatureType type = (FeatureType) entry.getKey();
                 Long count = (Long) entry.getValue();
     	public List getFeatureTypes() {
     		// Go through the map of FeatureTypes, and return only the ones that
     		// have at least a Feature.
     		List types = new ArrayList();
     		for (java.util.Iterator iterator = featureTypeCounts.entrySet()
     				.iterator(); iterator.hasNext();) {
     			Map.Entry entry = (Entry) iterator.next();
     			FeatureType type = (FeatureType) entry.getKey();
     			Long count = (Long) entry.getValue();
                 if (count.longValue() > 0) {
                     types.add(type);
+                }
+            }
     			if (count.longValue() > 0) {
     				types.add(type);
+    			}
+    		}
             return types;
+        }
     		return types;
+    	}
         public long getSize() throws DataException {
             return getSelectedCount();
+        }
     	public long getSize() throws DataException {
     		return getSelectedCount();
+    	}
         public boolean isEmpty() throws DataException {
             return getSelectedCount() == 0;
+        }
     	public boolean isEmpty() throws DataException {
     		return getSelectedCount() == 0;
+    	}
         /**
          * Returns the list of selected values, or the deselected ones if the
          * selection has been reversed.
          */
         public DisposableIterator iterator() {
             return iterator(0);
+        }
     	/**
     	 * Returns the list of selected values, or the deselected ones if the
     	 * selection has been reversed.
     	 */
     	public DisposableIterator iterator() {
     		return iterator(0);
+    	}
         /**
          * Returns the list of selected values, or the deselected ones if the
          * selection has been reversed.
+         *
          * WARN: not very good performance implementation.
          */
         public DisposableIterator iterator(long index) {
             return iterator(index, false);
+        }
     	/**
     	 * Returns the list of selected values, or the deselected ones if the
     	 * selection has been reversed.
+    	 *
     	 * WARN: not very good performance implementation.
     	 */
     	public DisposableIterator iterator(long index) {
     		return iterator(index, false);
+    	}
         /**
          * Returns the list of selected values, or the deselected ones if the
          * selection has been reversed.
+         *
          * WARN: not really a fast implementation.
          */
         public DisposableIterator fastIterator() {
             return fastIterator(0);
+        }
     	/**
     	 * Returns the list of selected values, or the deselected ones if the
     	 * selection has been reversed.
+    	 *
     	 * WARN: not really a fast implementation.
     	 */
     	public DisposableIterator fastIterator() {
     		return fastIterator(0);
+    	}
         /**
          * Returns the list of selected values, or the deselected ones if the
          * selection has been reversed.
+         *
          * WARN: not really a fast implementation.
          */
         public DisposableIterator fastIterator(long index) {
             return iterator(index, true);
+        }
     	/**
     	 * Returns the list of selected values, or the deselected ones if the
     	 * selection has been reversed.
+    	 *
     	 * WARN: not really a fast implementation.
     	 */
     	public DisposableIterator fastIterator(long index) {
     		return iterator(index, true);
+    	}
     	protected void clearFeatureReferences() {
     		super.clearFeatureReferences();
     		featureTypeCounts.clear();
+    	}
         protected void clearFeatureReferences() {
             super.clearFeatureReferences();
             featureTypeCounts.clear();
+        }
     	/**
     	 * Creates an iterator for the Selection.
     	 */
     	private DisposableIterator iterator(long index, boolean fastIterator) {
     		if (isReversed()) {
     			DisposableIterator iter = new ReversedFeatureIteratorFacade(
     					getData(), getFeatureStore(), fastIterator);
     			for (long l = 0; l < index && iter.hasNext(); l++) {
     				iter.next();
+    			}
     			return iter;
         /**
          * Creates an iterator for the Selection.
          */
         private DisposableIterator iterator(long index, boolean fastIterator) {
             if (isReversed()) {
                 DisposableIterator iter = new ReversedFeatureIteratorFacade(getData(),
                         getFeatureStore(), fastIterator);
                 for (long l = 0; l < index && iter.hasNext(); l++) {
                     iter.next();
+                }
                 return iter;
     		} else {
     			// TODO: maybe we could add a new referenceIterator(int index)
     			// method that could be implemented in a more performant way
             } else {
                 // TODO: maybe we could add a new referenceIterator(int index)
                 // method that could be implemented in a more performant way
     			java.util.Iterator iter = referenceIterator();
     			for (long l = 0; l < index && iter.hasNext(); l++) {
     				iter.next();
+    			}
     			return new FeatureIteratorFacade(iter, getFeatureStore());
+    		}
+    	}
                 java.util.Iterator iter = referenceIterator();
                 for (long l = 0; l < index && iter.hasNext(); l++) {
                     iter.next();
+                }
                 return new FeatureIteratorFacade(iter, getFeatureStore());
+            }
+        }
         private Long removeFeatureTypeCount(FeatureType featureType) {
     	private Long removeFeatureTypeCount(FeatureType featureType) {
     		Long count = (Long) featureTypeCounts.get(featureType);
     		if (count == null) {
     			count = new Long(-1);
-...
+    		}
     		featureTypeCounts.put(featureType, count);
     		return count;
+        }
+    	}
         /**
          * Facade over a Iterator of FeatureReferences, to return Features instead.
+         *
          * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
          */
         private class FeatureIteratorFacade implements DisposableIterator {
     	/**
     	 * Facade over a Iterator of FeatureReferences, to return Features instead.
+    	 *
     	 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
     	 */
     	private class FeatureIteratorFacade implements DisposableIterator {
             final Logger logger = LoggerFactory
                     .getLogger(FeatureIteratorFacade.class);
     		private final Logger LOGGER = LoggerFactory
     				.getLogger(FeatureIteratorFacade.class);
             private java.util.Iterator refIterator;
     		private java.util.Iterator refIterator;
             private FeatureStore featureStore;
     		private FeatureStore featureStore;
             public FeatureIteratorFacade(java.util.Iterator iter,
                     FeatureStore featureStore) {
                 this.refIterator = iter;
                 this.featureStore = featureStore;
+            }
     		public FeatureIteratorFacade(java.util.Iterator iter,
     				FeatureStore featureStore) {
     			this.refIterator = iter;
     			this.featureStore = featureStore;
+    		}
             public boolean hasNext() {
                 return refIterator.hasNext();
+            }
     		public boolean hasNext() {
     			return refIterator.hasNext();
+    		}
             public Object next() {
                 FeatureReference ref = nextFeatureReference();
                 try {
                     return featureStore.getFeatureByReference(ref);
                 } catch (DataException ex) {
                     logger.error(
                             "Error loading the Feature with FeatureReference: "
                                     + ref, ex);
                     return null;
+                }
+            }
     		public Object next() {
     			FeatureReference ref = nextFeatureReference();
     			try {
     				return featureStore.getFeatureByReference(ref);
     			} catch (DataException ex) {
     				LOGGER.error(
     						"Error loading the Feature with FeatureReference: "
     								+ ref, ex);
     				return null;
+    			}
+    		}
             /**
              * Returns the next FeatureReference.
+             *
              * @return the next FeatureReference
              */
             public FeatureReference nextFeatureReference() {
                 return (FeatureReference) refIterator.next();
+            }
     		/**
     		 * Returns the next FeatureReference.
+    		 *
     		 * @return the next FeatureReference
     		 */
     		public FeatureReference nextFeatureReference() {
     			return (FeatureReference) refIterator.next();
+    		}
             public void remove() {
                 refIterator.remove();
+            }
     		public void remove() {
     			refIterator.remove();
+    		}
             public void dispose() {
     		public void dispose() {
     			if (refIterator instanceof DisposableIterator) {
     				((DisposableIterator) refIterator).dispose();
+    			}
     			refIterator = null;
     			featureStore = null;
+    		}
+        }
+    	}
         /**
          * Facade over a Iterator of FeatureReferences, to return Features instead,
          * when the Selection is reversed
+         *
          * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
          */
         private class ReversedFeatureIteratorFacade implements DisposableIterator {
     	/**
     	 * Facade over a Iterator of FeatureReferences, to return Features instead,
     	 * when the Selection is reversed
+    	 *
     	 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>
     	 */
     	private class ReversedFeatureIteratorFacade implements DisposableIterator {
             private SelectionData selectionData;
     		private SelectionData selectionData;
             private DisposableIterator iterator;
     		private DisposableIterator iterator;
             private Feature nextFeature = null;
     		private Feature nextFeature = null;
     		private FeatureSet featureSet;
             public ReversedFeatureIteratorFacade(SelectionData selectionData,
                     FeatureStore featureStore, boolean fastIterator) {
                 this.selectionData = selectionData;
     		public ReversedFeatureIteratorFacade(SelectionData selectionData,
     				FeatureStore featureStore, boolean fastIterator) {
     			this.selectionData = selectionData;
                 // Load a Set with all the store features
                 try {
                     featureSet = featureStore.getFeatureSet();
                     if (fastIterator) {
                         iterator = featureSet.fastIterator();
                     } else {
                         iterator = featureSet.iterator();
+                    }
                 } catch (DataException ex) {
                     throw new ReversedSelectionIteratorException(ex);
+                }
     			// Load a Set with all the store features
     			try {
     				featureSet = featureStore.getFeatureSet();
     				if (fastIterator) {
     					iterator = featureSet.fastIterator();
     				} else {
     					iterator = featureSet.iterator();
+    				}
     			} catch (DataException ex) {
     				throw new ReversedSelectionIteratorException(ex);
+    			}
                 // Filter the features not selected and position in the next
                 // selected feature
                 positionInNextElement();
+            }
     			// Filter the features not selected and position in the next
     			// selected feature
     			positionInNextElement();
+    		}
             public boolean hasNext() {
                 return nextFeature != null;
+            }
     		public boolean hasNext() {
     			return nextFeature != null;
+    		}
             public Object next() {
                 Feature tmp = nextFeature;
                 positionInNextElement();
                 return tmp;
+            }
     		public Object next() {
     			Feature tmp = nextFeature.getCopy();
     			positionInNextElement();
     			return tmp;
+    		}
             public void remove() {
                 iterator.remove();
+            }
     		public void remove() {
     			iterator.remove();
+    		}
             private void positionInNextElement() {
                 nextFeature = null;
                 while (iterator.hasNext()) {
                     nextFeature = (Feature) iterator.next();
                     if (selectionData.contains(nextFeature.getReference())) {
                         nextFeature = null;
                     } else {
                         break;
+                    }
+                }
+            }
     		private void positionInNextElement() {
     			nextFeature = null;
     			while (iterator.hasNext()) {
     				nextFeature = (Feature) iterator.next();
     				if (selectionData.contains(nextFeature.getReference())) {
     					nextFeature = null;
     				} else {
     					break;
+    				}
+    			}
+    		}
     		public void dispose() {
     			this.featureSet.dispose();
-...
     			this.selectionData = null;
     			this.nextFeature = null;
+    		}
+        }
+    	}
         public void delete(Feature feature) throws DataException {
             throw new UnsupportedOperationException();
+        }
     	public void delete(Feature feature) throws DataException {
     		throw new UnsupportedOperationException();
+    	}
         public void insert(EditableFeature feature) throws DataException {
             throw new UnsupportedOperationException();
+        }
     	public void insert(EditableFeature feature) throws DataException {
     		throw new UnsupportedOperationException();
+    	}
         public void update(EditableFeature feature) throws DataException {
             throw new UnsupportedOperationException();
+        }
     	public void update(EditableFeature feature) throws DataException {
     		throw new UnsupportedOperationException();
+    	}
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @seeorg.gvsig.fmap.dal.feature.impl.DefaultFeatureReferenceSelection#
     	 * loadFromState(org.gvsig.tools.persistence.PersistentState)
     	 */
-...
     			throws PersistenceException {
     		super.loadFromState(state);
+    	}
     	public void accept(Visitor visitor) throws BaseException {
     		accept(visitor, 0);
+    	}
     	public void accept(Visitor visitor, long firstValueIndex)
     	public final void accept(Visitor visitor, long firstValueIndex)
     			throws BaseException {
     		try {
     			doAccept(visitor, firstValueIndex);
     		} catch (VisitCanceledException ex) {
     			// The visit has been cancelled by the visitor, so we finish here.
     			LOG.debug(
     					"The visit, beggining on position {}, has been cancelled "
     							+ "by the visitor: {}", new Long(firstValueIndex),
     					visitor);
+    		}
+    	}
     	private void doAccept(Visitor visitor, long firstValueIndex)
     			throws BaseException {
     		DisposableIterator iterator = fastIterator(firstValueIndex);
     		if (iterator != null) {
-...
     	public static void registerPersistent() {
     		PersistenceManager manager = ToolsLocator.getPersistenceManager();
     		DynStruct definition = manager.addDefinition(
     				DefaultFeatureSelection.class,
     				"DefaultFeatureSelection",
     				"DefaultFeatureSelection Persistent definition",
     				null,
     				null
     			);
     				DefaultFeatureSelection.class, "DefaultFeatureSelection",
     				"DefaultFeatureSelection Persistent definition", null, null);
     		definition.extend(
     			manager.getDefinition(DefaultFeatureReferenceSelection.DYNCLASS_PERSISTENT_NAME)
     		);
     		definition.addDynFieldMap("featureTypeCounts").setClassOfItems(Long.class).setMandatory(true);
     		definition
     				.extend(manager
     						.getDefinition(DefaultFeatureReferenceSelection.DYNCLASS_PERSISTENT_NAME));
     		definition.addDynFieldMap("featureTypeCounts")
     				.setClassOfItems(Long.class).setMandatory(true);
+    	}
     	public Object clone() throws CloneNotSupportedException {
     		DefaultFeatureSelection clone = (DefaultFeatureSelection) super.clone();
     		clone.featureTypeCounts = new HashMap(featureTypeCounts);
     		return clone;
+    	}
+    }

Also available in: Unified diff