Class Diff

  • Direct Known Subclasses:
    WFSDiff

    public class Diff
    extends Object
    Captures changes made to a FeatureStore prior to being committed.

    This is used to simulate the functionality of a database including transaction independence.

    Author:
    Jody Garnett
    • Field Detail

      • nextFID

        public int nextFID
        counter used to genreate the "next" new feature id
      • NULL

        public static final SimpleFeature NULL
        A NullObject used to represent the absence of a SimpleFeature.

        This class is used by TransactionStateDiff as a placeholder to represent features that have been removed. The concept is generally useful and may wish to be taken out as a separate class (used for example to represent deleted rows in a shapefile).

    • Constructor Detail

      • Diff

        public Diff()
        Create an empty Diff
      • Diff

        public Diff​(Diff other)
        Diff copy.
    • Method Detail

      • isEmpty

        public boolean isEmpty()
        Check if modifiedFeatures and addedFeatures are empty.
        Returns:
        true if Diff is empty
      • clear

        public void clear()
        Clear diff - called during rollback.
      • modify

        public void modify​(String fid,
                           SimpleFeature f)
        Record a modification to the indicated fid
        Parameters:
        f - replacement feature; null to indicate remove
      • addToSpatialIndex

        protected void addToSpatialIndex​(SimpleFeature f)
      • remove

        public void remove​(String fid)
      • getAddedOrder

        public List<String> getAddedOrder()
        Unmodifieable list indicating the order features were added
      • getModified

        public Map<String,​SimpleFeature> getModified()
        Unmodifiable view of modified features. It is imperative that the user manually synchronize on the map when iterating over any of its collection views:
          Set s = diff.modified2.keySet();  // Needn't be in synchronized block
              ...
          synchronized(diff) {  // Synchronizing on diff, not diff.modified2 or s!
              Iterator i = s.iterator(); // Must be in synchronized block
              while (i.hasNext())
                  foo(i.next());
          }
         
        Failure to follow this advice may result in non-deterministic behavior.

        The returned map will be serializable if the specified map is serializable.

        Returns:
        Map of modified features, null user to represent a removed feature
      • getAdded

        public Map<String,​SimpleFeature> getAdded()
        Unmodifiable view of added features. It is imperative that the user manually synchronize on the map when iterating over any of its collection views:
          Set s = diff.added.keySet();  // Needn't be in synchronized block
              ...
          synchronized(diff) {  // Synchronizing on m, not diff.added or s!
              Iterator i = s.iterator(); // Must be in synchronized block
              while (i.hasNext())
                  foo(i.next());
          }
         
        Failure to follow this advice may result in non-deterministic behavior.

        The returned map will be serializable if the specified map is serializable.

        Returns:
        Map of added features
      • copySTRtreeFrom

        protected Quadtree copySTRtreeFrom​(Diff diff)