org.geotools.data
Class Diff

Object
  Diff

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 Summary

Map<String,SimpleFeature>	added Deprecated. please use getAdded()
Map<String,SimpleFeature>	modified2 Deprecated. Please use getModified();
int	nextFID counter used to genreate the "next" new feature id
static SimpleFeature	NULL A NullObject used to represent the absence of a SimpleFeature.

Constructor Summary

Diff()
Create an empty Diff

Diff(Diff other)
Diff copy.

Method Summary

void	add(String fid, SimpleFeature f)
protected void	addToSpatialIndex(SimpleFeature f)
void	clear() Clear diff - called during rollback.
protected Quadtree	copySTRtreeFrom(Diff diff)
Map<String,SimpleFeature>	getAdded() Unmodifiable view of added features.
List<String>	getAddedOrder() Unmodifieable list indicating the order features were added
Map<String,SimpleFeature>	getModified() Unmodifiable view of modified features.
boolean	isEmpty() Check if modifiedFeatures and addedFeatures are empty.
void	modify(String fid, SimpleFeature f) Record a modification to the indicated fid
List<SimpleFeature>	queryIndex(Envelope env)
void	remove(String fid)

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

modified2

public final Map<String,SimpleFeature> modified2

Deprecated. Please use 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.

added

public final Map<String,SimpleFeature> added

Deprecated. please use 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.

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.

Parameters:

other -

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:

fid -

f - replacement feature; null to indicate remove

add

public void add(String fid,
                SimpleFeature f)

addToSpatialIndex

protected void addToSpatialIndex(SimpleFeature f)

remove

public void remove(String fid)

queryIndex

public List<SimpleFeature> queryIndex(Envelope env)

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)