Skip navigation links

oracle.spatial.topo
Class TopoMap

java.lang.Object
oracle.spatial.topo.TopoMap

public class TopoMap

extends java.lang.Object

A TopoMap object serves as a smart cache for a database topology. Working through a connection to the database, it stores edges, nodes, and faces and provides methods for adding, changing, and deleting elements while maintaining topological consistency both in the cache and in the underlying database tables via a transaction context. It also provides methods for navigating the cache, accessing the topology database, and validating the topology.

Field Summary

static int	BATCH_SIZE
static int	NOID
static int	UNIVERSE_FACE

Constructor Summary

TopoMap(java.sql.Connection con, java.lang.String topoName, int numberOfEdges, int numberOfNodes, int numberOfFaces)
Constructs a TopoMap object with a database Connection object and topology name.

TopoMap(java.sql.Connection con, java.lang.String topoName, int numberOfEdges, int numberOfNodes, int numberOfFaces, TopoPreprocess tp)
Constructs a TopoMap object with a database Connection object and topology name, and an object which implements the TopoPreprocess interface for preprocessing on invocation of addXXXX methods

Method Summary

int	addEdge(int node1, int node2, Point2DD[] coords) Adds an Edge to the topology, making all necessary adjustments to the surrounding topological context.
int	addIsolatedNode(int faceID, Point2DD p) Adds an isolated node inside of a face when the face ID is known.
int	addIsolatedNode(Point2DD p) Adds an isolated node inside of a face when the face ID is not known.
int[]	addLinearGeometry(JGeometry geom) Adds a linear (line string) geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph.
int[]	addLinearGeometry(Point2DD[] coords) Adds a linear (line string) geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph.
int	addLoop(int nodeID, Point2DD[] coords) Adds an edge that loops and connects to the same node.
int	addNode(int edgeID, Point2DD p, int coordIndex, boolean isNewShapePoint) Adds a node to an edge, splitting the edge in the process.
int	addPointGeometry(JGeometry geom) Adds a point geometry to the topology.
int	addPointGeometry(Point2DD coord) Adds a point to the topology.
int[]	addPolygonGeometry(JGeometry geom) Adds a polygon geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph.
int[]	addPolygonGeometry(Point2DD[] coords) Adds a single polygon geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the polygon with the edges and nodes in the topology graph.
void	changeEdgeCoords(int edge, Point2DD[] coords) Replaces the coordinate string for an edge without changing the topological context of the edge.
void	changeEdgeCoords(int edge, Point2DD[] coords, java.util.ArrayList movedIsoNodes, java.util.ArrayList movedIsoEdges, boolean allowIsoMoves) Replaces the coordinate string for an edge without changing the topological context of the edge.
void	clearCache() Clears all entities from the object cache.
void	clearCacheForNLW() Clears all entities from the object cache such that another loadWindow can be loaded witout doing a commit/rollback.
void	clearPreprocess() Clears the preprocessing listener for addXXXX methods
void	closeStmt() Closes the statement cursor.
void	commitDB() Commits any updates to the database and clears any row locks.
void	createEdgeIndex() Builds a ram-resident R-tree index for the edge cache.
void	createFaceIndex() Builds a ram-resident R-tree index for the face cache.
void	dispose()
Point2DD[]	getCacheBounds() Determines the bounds of the data contained in the cache, using the index in the cache; useful for determining plot bounds, for example.
int	getCacheEdgeCount() Returns the number of edges in the cache.
int	getCacheFaceCount() Returns the number of faces in the cache.
int	getCacheNodeCount() Returns the number of nodes in the cache.
static java.sql.Connection	getConnection(java.lang.String connectString, java.lang.String userID, java.lang.String passwd) Static method to build a JDBC Connection object from a connection string, user ID, and password.
int	getContainingFace(Point2DD p) From the faces in the instance cache, determines the one, if any, that contains the test point in its open set.
Edge	getEdge(int id) Returns a reference to an Edge object given its logical ID.
java.util.ArrayList	getEdgeAdditions() Provides a list of the edges that have been added in the cache.
java.util.ArrayList	getEdgeChanges() Provides a list of the edges that have been changed in the cache.
java.util.ArrayList	getEdgeDeletions() Provides a list of the edges that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.
java.util.Iterator	getEdgeIterator() Provides an Iterator for traversal of all the Edge objects contained in the instance cache.
Face	getFace(int id) Returns a reference to a Face object given its logical ID.
java.util.ArrayList	getFaceAdditions() Provides a list of the faces that have been added in the cache.
int[]	getFaceBoundary(int faceID, int option) Returns an array of edge IDs making up the boundary of a face, with several options
java.util.ArrayList	getFaceChanges() Provides a list of the faces that have been changed in the cache.
java.util.ArrayList	getFaceDeletions() Provides a list of the faces that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.
java.util.Iterator	getFaceIterator() Provides an Iterator for traversal of all the Face objects contained in the instance cache.
boolean	getIsEditable() Returns the editing state.
int	getNearestEdge(Point2DD point) Returns the ID of the Edge object that is nearest to the specified point.
int	getNearestEdgeInCache(Point2DD point) Returns the ID of the Edge object that of the edges loaded in the cache is nearest to the specified point.
int	getNearestNode(Point2DD point) Returns the ID of the Node object that is nearest to the specified point.
int	getNearestNodeInCache(Point2DD p) Returns the ID of the Node object that of the nodes loaded in the cache is nearest to the specified point.
Node	getNode(int id) Returns a reference to a Node object given its logical ID.
java.util.ArrayList	getNodeAdditions() Provides a list of the nodes that have been added in the cache.
java.util.ArrayList	getNodeChanges() Provides a list of the nodes that have been changed in the cache.
java.util.ArrayList	getNodeDeletions() Provides a list of the nodes that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.
int[]	getNodeFaceStar(int nodeID) Gets an array of integers representing the IDs of a clockwise enumeration of all the faces adjoining the given node.
java.util.Iterator	getNodeIterator() Provides an Iterator for traversal of all the Node objects contained in the instance cache.
int[]	getNodeStar(int nodeID) Gets an array of integers representing the IDs of a clockwise enumeration of all the edges connected to the given node.
int	getNodeStarCount(int nodeID) Gets a count of the number of edges connected at a node.
int	getSrid() Returns the SRID of the topology.
Point2DD[]	getTopologyBounds() Determines the bounds of the data contained in the database topology, using the spatial index in the database.
int	getTopologyEdgeCount() Returns the number of edges in the <topologyName>_EDGE$ table.
int	getTopologyFaceCount() Returns the number of faces in the <topologyName>_FACE$ table.
int	getTopologyNodeCount() Returns the number of nodes in the <topologyName>_NODE$ table.
java.lang.String	getTopoName() Returns the name of the topology.
int	getTopoTransactionID() Returns the topology transaction ID if there is data loaded in the cache for update.
Edge	loadEdge(int id) Loads an edge from the database if the edge is not already in the cache.
Face	loadFace(int id) Loads a face from the database if the face is not already in the cache.
Node	loadNode(int id) Loads a node from the database if the node is not already in the cache.
boolean	loadTopology(boolean lockForUpdate) Loads the entire topology from the database into the instance cache.
boolean	loadTopology(boolean lockForUpdate, boolean buildIndexes) Loads the entire topology from the database into the instance cache.
boolean	loadWindow(double xMin, double yMin, double xMax, double yMax, boolean lockForUpdate) Loads a portion of the topology specified by a query window.
boolean	loadWindow(double xMin, double yMin, double xMax, double yMax, boolean lockForUpdate, boolean buildIndexes) Loads a portion of the topology specified by a query window.
boolean	loadWindow(double xMin, double yMin, double xMax, double yMax, boolean lockForUpdate, boolean buildIndexes, boolean nextLoadWindow) Loads a portion of the topology specified by a query window.
static void	main(java.lang.String[] args)
void	moveEdge(int edgeID, int sNodeID, int tNodeID, Point2DD[] edgeCoords) Moves one endpoint of an edge and changes the edge coordinates after checking that no topological changes would be required, other than some possible exceptions.
void	moveEdge(int edgeID, int sNodeID, int tNodeID, Point2DD[] edgeCoords, java.util.ArrayList movedIsoNodes, java.util.ArrayList movedIsoEdges, boolean allowIsoMoves) Moves one endpoint of an edge and changes the edge coordinates after checking that no topological changes would be required, other than some possible exceptions.
void	moveIsolatedNode(int nodeID, Point2DD point) Moves an isolated node.
void	moveNode(int nodeID, Point2DD[][] edgesCoords) Moves a node and its attached edges after checking that no topological changes would be required, except that island edges and nodes may change containing faces.
void	moveNode(int nodeID, Point2DD[][] edgesCoords, java.util.ArrayList movedIsoNodes, java.util.ArrayList movedIsoEdges, boolean allowIsoMoves) Moves a node and its attached edges after checking that no topological changes would be required.
void	removeEdge(int edgeID) Remove an edge, merging faces if there are different faces on each side of the edge.
void	removeNode(int nodeID) Removes an isolated node or a node at the joining of two edges, merging the edges into one.
boolean	removeObsoleteNodes() Removes any nodes in the cache which are connected to two and only two distinct edges, are not assigned to point features, and do not serve as the demarcation between mismatched linear features.
void	rollbackDB() Rolls back any updates to the database and clears any row locks.
boolean	searchEdgeRTree(double[][] h, java.util.ArrayList a) Return the list of edges from edgeRtree for the given query MBR.
boolean	searchFaceRTree(double[][] h, java.util.ArrayList a) Return the list of faces from faceRtree for the given query MBR.
void	setPreprocess(TopoPreprocess tp) Sets the preprocessing listener for addXXXX methods
double	snapToGrid(double d) Snaps a single double precision value to the instance grid
void	snapToGrid(Point2DD p) Snaps the coordinate pair of the argument Point2DD to the instance grid.
void	snapToGrid(Point2DD[] p) Snaps all the coordinate pairs of the array of Point2DD to the instance grid.
void	updateTopology() Updates to the database topological changes in the instance.
boolean	validateCache() Wrapper for validateCache(int level).
boolean	validateCache(int level) Performs a topological validation of the cache, checking the consistency of all pointer relationships in the edge/node/face graph.

Methods inherited from class java.lang.Object

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

Field Detail

NOID

public static final int NOID

See Also:

Constant Field Values

UNIVERSE_FACE

public static final int UNIVERSE_FACE

See Also:

Constant Field Values

BATCH_SIZE

public static final int BATCH_SIZE

See Also:

Constant Field Values

Constructor Detail

TopoMap

public TopoMap(java.sql.Connection con,
               java.lang.String topoName,
               int numberOfEdges,
               int numberOfNodes,
               int numberOfFaces,
               TopoPreprocess tp)
        throws java.sql.SQLException,
               TopoEntityNotFoundException

Constructs a TopoMap object with a database Connection object and topology name, and an object which implements the TopoPreprocess interface for preprocessing on invocation of addXXXX methods

Parameters:

con - an Oracle Connection object (produced, for example, by a call to getConnection() )

topoName - the name of the topology in the database

numberOfEdges - best estimate of the number of edges to be loaded into the object cache at one time. Will not overflow if the estimate is too low.

numberOfNodes - like numberOfEdges; typically there will be half the number of edges

numberOfFaces - like numberOfEdges; typically there will be half the number of edges

tp - An implementation of the TopoPreprocess interface

Throws:

java.sql.SQLException

TopoEntityNotFoundException

TopoMap

public TopoMap(java.sql.Connection con,
               java.lang.String topoName,
               int numberOfEdges,
               int numberOfNodes,
               int numberOfFaces)
        throws java.sql.SQLException,
               TopoEntityNotFoundException

Constructs a TopoMap object with a database Connection object and topology name.

Parameters:

con - an Oracle Connection object (produced, for example, by a call to getConnection() )

topoName - the name of the topology in the database

numberOfEdges - best estimate of the number of edges to be loaded into the object cache at one time. Will not overflow if the estimate is too low.

numberOfNodes - like numberOfEdges; typically there will be half the number of edges

numberOfFaces - like numberOfEdges; typically there will be half the number of edges

Throws:

java.sql.SQLException

TopoEntityNotFoundException

Method Detail

getConnection

public static java.sql.Connection getConnection(java.lang.String connectString,
                                                java.lang.String userID,
                                                java.lang.String passwd)
                                         throws java.sql.SQLException,
                                                java.lang.ClassNotFoundException

Static method to build a JDBC Connection object from a connection string, user ID, and password. Use it to get a Connection object for the TopoMap constructor.

Parameters:

connectString - a connection string, for example: "jdbc:oracle:thin:@<host>:<port>:<sid>" - for a thin JDBC driver, or "jdbc:oracle:oci:@<host>:<port>:<sid>" - for a thick JDBC driver

userID - user ID for database

passwd - the password for the user account

Returns:

the JDBC connection object

Throws:

java.sql.SQLException - if cannot get connection from the database

java.lang.ClassNotFoundException - if unable to load the OracleDriver class

snapToGrid

public void snapToGrid(Point2DD p)

Snaps the coordinate pair of the argument Point2DD to the instance grid.

Parameters:

p - the input point

snapToGrid

public double snapToGrid(double d)

Snaps a single double precision value to the instance grid

Parameters:

d - the input double

Returns:

the snapped double

snapToGrid

public void snapToGrid(Point2DD[] p)

Snaps all the coordinate pairs of the array of Point2DD to the instance grid. Snapping may result in duplicate points. These duplicate points will be removed, and therefore the Point2DD[] may not have the same length on return.

Parameters:

p - the array of points

setPreprocess

public void setPreprocess(TopoPreprocess tp)

Sets the preprocessing listener for addXXXX methods

Parameters:

tp - An object implementing the TopoPreprocess interface

clearPreprocess

public void clearPreprocess()

Clears the preprocessing listener for addXXXX methods

Parameters:

tp - An object implementing the TopoPreprocess interface

getTopologyEdgeCount

public int getTopologyEdgeCount()
                         throws java.sql.SQLException

Returns the number of edges in the <topologyName>_EDGE$ table.

Returns:

the edge count

Throws:

java.sql.SQLException

getCacheEdgeCount

public int getCacheEdgeCount()

Returns the number of edges in the cache.

Returns:

the edge count

getCacheNodeCount

public int getCacheNodeCount()

Returns the number of nodes in the cache.

Returns:

the node count

getCacheFaceCount

public int getCacheFaceCount()

Returns the number of faces in the cache.

Returns:

the face count

getTopologyNodeCount

public int getTopologyNodeCount()
                         throws java.sql.SQLException

Returns the number of nodes in the <topologyName>_NODE$ table.

Returns:

the node count

Throws:

java.sql.SQLException

getTopologyFaceCount

public int getTopologyFaceCount()
                         throws java.sql.SQLException

Returns the number of faces in the <topologyName>_FACE$ table.

Returns:

the face count

Throws:

java.sql.SQLException

createEdgeIndex

public void createEdgeIndex()
                     throws java.lang.Exception

Builds a ram-resident R-tree index for the edge cache. A packed tree is built using recursive sorting.

Throws:

java.lang.Exception

createFaceIndex

public void createFaceIndex()
                     throws java.lang.Exception

Builds a ram-resident R-tree index for the face cache. A packed tree is built using recursive sorting.

Throws:

java.lang.Exception

clearCache

public void clearCache()
                throws java.sql.SQLException,
                       InvalidTopoOperationException

Clears all entities from the object cache. Also clears the record of changed or added entities. If these need to be saved to the database, be sure to call updateTopology() and/or commitDB() first. The cache cannot be cleared if a call to updateTopology() has been made and a call to either rollbackDB() or commitDB() has not been made. rollBackDB() also clears the cache as a side effect, so a call to clearCache() would be superfluous in that case.

Throws:

java.sql.SQLException

InvalidTopoOperationException

clearCacheForNLW

public void clearCacheForNLW()
                      throws java.sql.SQLException,
                             InvalidTopoOperationException

Clears all entities from the object cache such that another loadWindow can be loaded witout doing a commit/rollback. This is similar to the clearCache except that this is called as pre-step to the next loadWindow call. All the rules of clearCache apply here as well.

Throws:

java.sql.SQLException

InvalidTopoOperationException

getCacheBounds

public Point2DD[] getCacheBounds()
                          throws InvalidTopoOperationException

Determines the bounds of the data contained in the cache, using the index in the cache; useful for determining plot bounds, for example. The returned window bounds may be larger than the bounds passed to loadWindow() when the cache was loaded because of either or both of the following: (1) ragged retrieval of edges bounding faces that overlap the edit window; (2) other entities that might have been cached by direct calls to loadEdge() or other methods.

Returns:

the mbr of all the edge, node, and face entities in the cache as an array of two Point2DD objects: [0] is the min x,y and [1] is max x,y

Throws:

InvalidTopoOperationException

getTopologyBounds

public Point2DD[] getTopologyBounds()
                             throws java.sql.SQLException,
                                    InvalidTopoOperationException

Determines the bounds of the data contained in the database topology, using the spatial index in the database.

Returns:

the mbr of all the edge, node, and face entities in the topology as an array of two Point2DD objects: [0] is the min x,y and [1] is max x,y

Throws:

java.sql.SQLException

InvalidTopoOperationException

loadWindow

public boolean loadWindow(double xMin,
                          double yMin,
                          double xMax,
                          double yMax,
                          boolean lockForUpdate)
                   throws java.sql.SQLException,
                          TopoEntityNotFoundException,
                          InvalidTopoOperationException,
                          java.lang.Exception

Loads a portion of the topology specified by a query window. Loads all edges, nodes, and faces which intersect the query window. For faces, also loads any edges and isolated nodes on the boundary of the face, even if they do not intersect the query window. This is to ensure that everything is loaded that might be needed or affected by a topological editing operation, or for validation of the data in the window.

If there is a prior transaction that has been initiated, it must be committed (via commitDB) or rolled back (via rollbackDB) before this method can be called for read-only access, even if the cache has been cleared. The lockForUpdate flag must be true if any edits are to be performed on the data. The client application will be able to delete, modify, or add elements only inside the window specified in the call to this routine. Data cannot be loaded if there is already data loaded. This method automatically builds indexes in the cache for edges and faces.

Parameters:

xMin - the minimum x-value of the query window

yMin - the minimum y-value of the query window

xMax - the maximum x-value of the query window

yMax - the maximum y-value of the query window

lockForUpdate - set true if you intend to edit inside the window and update the database. The retrieved entities will be locked for update by others.

Returns:

true if something was loaded; false otherwise

Throws:

java.sql.SQLException

TopoEntityNotFoundException

InvalidTopoOperationException

java.lang.Exception

loadWindow

public boolean loadWindow(double xMin,
                          double yMin,
                          double xMax,
                          double yMax,
                          boolean lockForUpdate,
                          boolean buildIndexes)
                   throws java.sql.SQLException,
                          TopoEntityNotFoundException,
                          InvalidTopoOperationException,
                          java.lang.Exception

Loads a portion of the topology specified by a query window. Loads all edges, nodes, and faces which intersect the query window. For faces, also loads any edges and isolated nodes on the boundary of the face even if they do not intersect the query window. Finally, loads the start and end nodes of any edge that has been loaded unless they are already loaded. This is to ensure that everything is loaded that might be needed or affected by a topological editing operation, or for validation of the data in the window.

If there is a prior transaction that has been initiated, it must be committed (via commitDB) or rolled back (via rollbackDB) before this method can be called for read-only access, even if the cache has been cleared. The lockForUpdate flag must be true if any edits are to be performed on the data. The client application will be able to delete, modify, or add elements only inside the window specified in the call to this routine. Data cannot be loaded if there is already data loaded. At the user's option, the edges and faces can be indexed in the cache.

Parameters:

xMin - The minimum x-value of the query window

yMin - The minimum y-value of the query window

xMax - The maximum x-value of the query window

yMax - The maximum y-value of the query window

lockForUpdate - set true if you intend to edit inside the window and update the database. The retrieved entities will be locked for update by others.

buildIndexes - set true to auto-build indexes in the cache for edges and faces

Returns:

true if something was loaded; false otherwise

Throws:

java.sql.SQLException

TopoEntityNotFoundException

InvalidTopoOperationException

java.lang.Exception

loadWindow

public boolean loadWindow(double xMin,
                          double yMin,
                          double xMax,
                          double yMax,
                          boolean lockForUpdate,
                          boolean buildIndexes,
                          boolean nextLoadWindow)
                   throws java.sql.SQLException,
                          TopoEntityNotFoundException,
                          InvalidTopoOperationException,
                          java.lang.Exception

Loads a portion of the topology specified by a query window. Loads all edges, nodes, and faces which intersect the query window. For faces, also loads any edges and isolated nodes on the boundary of the face even if they do not intersect the query window. Finally, loads the start and end nodes of any edge that has been loaded unless they are already loaded. This is to ensure that everything is loaded that might be needed or affected by a topological editing operation, or for validation of the data in the window.

If there is a prior transaction that has been initiated, this loadWindow method will continue that txn, provided a updateTopology() is issued before calling this method. The lockForUpdate flag must be true if any edits are to be performed on the data. The client application will be able to delete, modify, or add elements only inside the window specified in the call to this routine. Data cannot be loaded if there is already data loaded. At the user's option, the edges and faces can be indexed in the cache.

Parameters:

xMin - The minimum x-value of the query window

yMin - The minimum y-value of the query window

xMax - The maximum x-value of the query window

yMax - The maximum y-value of the query window

lockForUpdate - set true if you intend to edit inside the window and update the database. The retrieved entities will be locked for update by others.

buildIndexes - set true to auto-build indexes in the cache for edges and faces

nextLoadWindow - set true if this is not the first loadWindow in a sequence of loadWindow operations

Returns:

true if something was loaded; false otherwise

Throws:

java.sql.SQLException

TopoEntityNotFoundException

InvalidTopoOperationException

java.lang.Exception

loadTopology

public boolean loadTopology(boolean lockForUpdate)
                     throws java.sql.SQLException,
                            InvalidTopoOperationException,
                            TopoEntityNotFoundException,
                            java.lang.Exception

Loads the entire topology from the database into the instance cache. If there is a prior transaction that has been initiated, it must be committed (via commitDB) or rolled back (via rollbackDB) before this method can be called for read-only access, even if the cache has been cleared. Data cannot be loaded if there is data already in the cache. This method will auto-build R-tree indexes for edges and faces

Parameters:

lockForUpdate - whether the data is loaded read-only (false) or for editing (true).

Returns:

true if anything was loaded; false otherwise

Throws:

java.sql.SQLException

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

loadTopology

public boolean loadTopology(boolean lockForUpdate,
                            boolean buildIndexes)
                     throws java.sql.SQLException,
                            InvalidTopoOperationException,
                            TopoEntityNotFoundException,
                            java.lang.Exception

Loads the entire topology from the database into the instance cache. If there is a prior transaction that has been initiated, it must be committed (via commitDB) or rolled back (via rollbackDB) before this method can be called for read-only access, even if the cache has been cleared. Data cannot be loaded if there is data already in the cache. At the user's option, indexes can be built for edges and nodes in the cache.

Parameters:

lockForUpdate - whether the data is loaded read-only (false) or for editing (true).

buildIndexes - whether (true) or not (false) to build edge and face indexes

Returns:

true if anything was loaded; false otherwise

Throws:

java.sql.SQLException

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

updateTopology

public void updateTopology()
                    throws java.sql.SQLException,
                           TopoEntityNotFoundException,
                           TopoValidationException,
                           java.lang.Exception

Updates to the database topological changes in the instance. Database changes are NOT committed by this method and locks are still active. The window of data is still editable, but nothing remains on the lists of added, changed, and deleted entities.

If the data has not been validated (via a call to validateCache(0) ) since anything was changed, a call to validateCache(0) is made implicitly by this method before updating the database. If any exception except a TopoValidationException is raised, the connection is rolled back (which clears the cache implicitly) before the exception is rethrown.

Throws:

java.sql.SQLException

TopoEntityNotFoundException

TopoValidationException

java.lang.Exception

commitDB

public void commitDB()
              throws java.sql.SQLException,
                     TopoEntityNotFoundException,
                     TopoValidationException,
                     java.lang.Exception

Commits any updates to the database and clears any row locks. Implicitly calls updateTopology to flush any changed or added entities from the cache to the database. The data in the cache is set uneditable since there are no more database locks.

Throws:

java.sql.SQLException

TopoEntityNotFoundException

TopoValidationException

java.lang.Exception

rollbackDB

public void rollbackDB()
                throws java.sql.SQLException

Rolls back any updates to the database and clears any row locks. The data in the cache is also cleared.

Throws:

java.sql.SQLException

searchEdgeRTree

public boolean searchEdgeRTree(double[][] h,
                               java.util.ArrayList a)

Return the list of edges from edgeRtree for the given query MBR.

Parameters:

h - two dimensional array of doubles which are the minimum bounding MBR defining the search. The first index ranges over 0,1 (X and Y) and is the dimension of the space. The second index ranges over 0,1 and specifies the min and max.

a - The ArrayList holds the objects found to satisfy the search. Should be preallocated by the caller and set via the constructor or ensureCapacity(int) for expected result size (for efficiency). Will not overflow if undersized.

Returns:

true if there are some results of the search; false if none. ArrayList a.size() will return the number of hits.

searchFaceRTree

public boolean searchFaceRTree(double[][] h,
                               java.util.ArrayList a)

Return the list of faces from faceRtree for the given query MBR.

Parameters:

h - two dimensional array of doubles which are the minimum bounding MBR defining the search. The first index ranges over 0,1 (X and Y) and is the dimension of the space. The second index ranges over 0,1 and specifies the min and max.

a - The ArrayList holds the objects found to satisfy the search. Should be preallocated by the caller and set via the constructor or ensureCapacity(int) for expected result size (for efficiency). Will not overflow if undersized.

Returns:

true if there are some results of the search; false if none. ArrayList a.size() will return the number of hits.

getEdge

public Edge getEdge(int id)
             throws TopoEntityNotFoundException

Returns a reference to an Edge object given its logical ID. If the object is not found in the cache, a TopoEntityNotFoundException is thrown.

Parameters:

id - the entity's logical ID

Returns:

the Edge reference

Throws:

TopoEntityNotFoundException

getNode

public Node getNode(int id)
             throws TopoEntityNotFoundException

Returns a reference to a Node object given its logical ID. If the object is not found in the cache, a TopoEntityNotFoundException is thrown.

Parameters:

id - the entity's logical ID

Returns:

the Node reference

Throws:

TopoEntityNotFoundException

getFace

public Face getFace(int id)
             throws TopoEntityNotFoundException

Returns a reference to a Face object given its logical ID. If the object is not found in the cache, a TopoEntityNotFoundException is thrown.

Parameters:

id - the entity's logical ID

Returns:

the Face reference

Throws:

TopoEntityNotFoundException

getFaceBoundary

public int[] getFaceBoundary(int faceID,
                             int option)
                      throws TopoEntityNotFoundException,
                             TopoDataException

Returns an array of edge IDs making up the boundary of a face, with several options

Parameters:

faceID - The face for which the boundary edges are desired

option - What type of boundary return is desired (0, 1, or 2).

0 = external boundary ring without doubly traced edges (spurs)

1 = external and internal rings without spurs

2 = external and internal rings with spurs - i.e. the full, possibly degenerate, boundary

Returns:

an array of ints representing the list of boundary edge IDs. Edge IDs appear in the array once only and in positive sense only

Throws:

TopoEntityNotFoundException

TopoDataException

getNearestEdge

public int getNearestEdge(Point2DD point)
                   throws java.sql.SQLException,
                          TopoEntityNotFoundException

Returns the ID of the Edge object that is nearest to the specified point. The determination of the nearest edge is made from the representation of the topology in the database, using the spatial index.

If there are changed, added, or deleted edges in the instance and if the database has not been updated to reflect those changes, the result of this operator may not reflect the true situation in the cache.

Parameters:

point - the point for which the closest edge is sought

Returns:

the ID of the nearest edge

Throws:

java.sql.SQLException

TopoEntityNotFoundException

getNearestEdgeInCache

public int getNearestEdgeInCache(Point2DD point)

Returns the ID of the Edge object that of the edges loaded in the cache is nearest to the specified point. In case of ties, any of the tying edges may be returned. If no data is loaded or there are no edges in the cache, returns NOID.

Parameters:

point - the point for which the closest edge is sought

Returns:

the ID of the nearest edge

getNearestNode

public int getNearestNode(Point2DD point)
                   throws java.sql.SQLException,
                          TopoEntityNotFoundException

Returns the ID of the Node object that is nearest to the specified point. The determination of the nearest node is made from the representation of the topology in the database, using the spatial index.

If there are changed, added, or deleted nodes in the instance and if the database has not been updated to reflect those changes, the result of this operator may not reflect the true situation in the cache.

Parameters:

point - the point for which the closest node is sought

Returns:

the ID of the nearest node

Throws:

java.sql.SQLException

TopoEntityNotFoundException

getNearestNodeInCache

public int getNearestNodeInCache(Point2DD p)

Returns the ID of the Node object that of the nodes loaded in the cache is nearest to the specified point. In case of ties, any of the tying nodes may be returned. If no data is loaded or there are no nodes in the cache, returns NOID.

Parameters:

p - the point for which the closest node is sought

Returns:

the ID of the nearest node

getEdgeIterator

public java.util.Iterator getEdgeIterator()

Provides an Iterator for traversal of all the Edge objects contained in the instance cache.

Returns:

an Iterator over a Collection of Edges

getNodeIterator

public java.util.Iterator getNodeIterator()

Provides an Iterator for traversal of all the Node objects contained in the instance cache.

Returns:

an Iterator over a Collection of Nodes

getFaceIterator

public java.util.Iterator getFaceIterator()

Provides an Iterator for traversal of all the Face objects contained in the instance cache.

Returns:

an Iterator over a Collection of Faces

getEdgeChanges

public java.util.ArrayList getEdgeChanges()

Provides a list of the edges that have been changed in the cache. These are the edges that have been changed since the cache topology was loaded from the database, but have not yet been written back out to the database.

Returns:

an ArrayList holding Integer objects wrapping edge IDs

getNodeChanges

public java.util.ArrayList getNodeChanges()

Provides a list of the nodes that have been changed in the cache. These are the nodes that have been changed since the cache topology was loaded from the database, but have not yet been written back out to the database.

Returns:

an ArrayList holding Integer objects wrapping node IDs

getFaceChanges

public java.util.ArrayList getFaceChanges()

Provides a list of the faces that have been changed in the cache. These are the faces that have been changed since the cache topology was loaded from the database, but have not yet been written back out to the database.

Returns:

an ArrayList holding Integer objects wrapping face IDs

getEdgeAdditions

public java.util.ArrayList getEdgeAdditions()

Provides a list of the edges that have been added in the cache. These are the edges that have been created since the cache topology was loaded from the database, but have not yet been written out to the database.

Returns:

an ArrayList holding Integer objects wrapping edge IDs

getNodeAdditions

public java.util.ArrayList getNodeAdditions()

Provides a list of the nodes that have been added in the cache. These are the nodes that have been created since the cache topology was loaded from the database, but have not yet been written out to the database.

Returns:

an ArrayList holding Integer objects wrapping node IDs

getFaceAdditions

public java.util.ArrayList getFaceAdditions()

Provides a list of the faces that have been added in the cache. These are the faces that have been created since the cache topology was loaded from the database, but have not yet been written out to the database.

Returns:

an ArrayList holding Integer objects wrapping face IDs

getEdgeDeletions

public java.util.ArrayList getEdgeDeletions()

Provides a list of the edges that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.

Returns:

an ArrayList holding Integer objects wrapping edge IDs

getNodeDeletions

public java.util.ArrayList getNodeDeletions()

Provides a list of the nodes that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.

Returns:

an ArrayList holding Integer objects wrapping node IDs

getFaceDeletions

public java.util.ArrayList getFaceDeletions()

Provides a list of the faces that have been marked as deleted in the cache: deleted since the cache topology was loaded from the database, but not yet removed from the database.

Returns:

an ArrayList holding Integer objects wrapping face IDs

moveIsolatedNode

public void moveIsolatedNode(int nodeID,
                             Point2DD point)
                      throws InvalidTopoOperationException,
                             TopoEntityNotFoundException,
                             java.sql.SQLException,
                             java.lang.Exception

Moves an isolated node. The node must be carried to a location inside the face currently owning it. Otherwise, it must be deleted and recreated. If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

nodeID - the ID of the node being moved

point - the new node coordinate

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.sql.SQLException

java.lang.Exception

moveNode

public void moveNode(int nodeID,
                     Point2DD[][] edgesCoords)
              throws InvalidTopoOperationException,
                     TopoEntityNotFoundException,
                     java.lang.Exception,
                     java.sql.SQLException

Moves a node and its attached edges after checking that no topological changes would be required, except that island edges and nodes may change containing faces. Since no topological elements are allowed to be created or destroyed (or even modified in most cases), there are no changes to the relationships of features to topological elements as a result of this method.

If the node is isolated, you must use the method moveIsolatedNode() which has a simpler interface.

Parameters:

nodeID - the ID of the node being moved with its attached edges

edgesCoords - an array of arrays of new edge coordinates for each attached edge, starting with the node start edge and proceeding in clockwise sequence as would be obtained by a call to getNodeStar(). The array for each edge must include the endpoints, match the others at the moved node and be unchanged at the other node, and be in the same sense as the original edge. Any loops which connect twice at the moved node should be in the array twice, again in the same sense.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

java.sql.SQLException

moveNode

public void moveNode(int nodeID,
                     Point2DD[][] edgesCoords,
                     java.util.ArrayList movedIsoNodes,
                     java.util.ArrayList movedIsoEdges,
                     boolean allowIsoMoves)
              throws InvalidTopoOperationException,
                     TopoEntityNotFoundException,
                     java.lang.Exception,
                     java.sql.SQLException

Moves a node and its attached edges after checking that no topological changes would be required. There is one class of topological changes optionally permitted: At user choice, island edges and nodes may be allowed to change containing faces. Since no topological elements are allowed to be created or destroyed (or even modified in most cases), there are no changes to the relationships of features to topological elements as a result of this method

If the node is isolated, you must use the method moveIsolatedNode(), which has a simpler interface.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

nodeID - the ID of the node being moved with its attached edges

edgesCoords - an array of arrays of new edge coordinates for each attached edge, starting with the node start edge and proceeding in clockwise sequence as would be obtained by a call to getNodeStar(). The array for each edge must include the endpoints, match the others at the moved node and be unchanged at the other node, and be in the same sense as the original edge. Any loops which connect twice at the moved node should be in the array twice, again in the same sense.

movedIsoNodes - allocate with default capacity; this method will fill it with the IDs of isolated nodes which change faces as a result of the move

movedIsoEdges - allocate with default capacity; this method will fill it with the IDs of isolated edges which change faces as a result of the move

allowIsoMoves - whether (true) or not (false) to allow a node move operation that would cause any isolated nodes or edges to be in a different face. If such moves are allowed and any do occur, the containing face information for such isolated nodes and edges is adjusted.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

java.sql.SQLException

moveEdge

public void moveEdge(int edgeID,
                     int sNodeID,
                     int tNodeID,
                     Point2DD[] edgeCoords)
              throws InvalidTopoOperationException,
                     TopoEntityNotFoundException,
                     java.lang.Exception,
                     java.sql.SQLException

Moves one endpoint of an edge and changes the edge coordinates after checking that no topological changes would be required, other than some possible exceptions. The possible exceptions are:

• There will be topological changes at the node from which the edge is lifted and at the node to which the edge is reattached.
• Some edges may change which boundary component they are a part of and therefore have their face pointers changed on one side.
• Island edges and nodes may change containing faces. In the case of island edges this means that entire inner boundary components may change faces.

Because no topological changes are permitted at the unmoved end of the edge, this also precludes a loop edge being opened up or a non-loop edge being turned into a loop, and this will be trapped.

The edge to be moved must have different faces on each side. That means the edge is part of two face boundary components, at least one of which must be the outside boundary component of its face.

The node to which the end of the edge is moved must be located in one of the two boundary components of which the original edge is a part; that is, the node must be reachable in a trace starting with the edge's nextEdgeL or nextEdgeR. Note that it is possible for the two boundary components to be the inside and outside of the same component, in which case the destination node would be found in both.

Since no topological elements are allowed to be created or destroyed (or even modified in most cases), there are no changes to the relationships of features to topological elements as a result of this method.

Parameters:

edgeID - the moved edge

sNodeID - the ID of the node from which the edge is detached (source node)

tNodeID - the ID of the node to which the edge is reattached (target node)

edgeCoords - an array of coordinates for the moved edge. The array must match the node coordinates at the new node and at the node at the other end, and be in the same sense as the old edge coordinates.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

java.sql.SQLException

moveEdge

public void moveEdge(int edgeID,
                     int sNodeID,
                     int tNodeID,
                     Point2DD[] edgeCoords,
                     java.util.ArrayList movedIsoNodes,
                     java.util.ArrayList movedIsoEdges,
                     boolean allowIsoMoves)
              throws InvalidTopoOperationException,
                     TopoEntityNotFoundException,
                     java.lang.Exception,
                     java.sql.SQLException

Moves one endpoint of an edge and changes the edge coordinates after checking that no topological changes would be required, other than some possible exceptions. The possible exceptions are:

• There will be topological changes at the node from which the edge is lifted and at the node to which the edge is reattached.
• Some edges may change which boundary component they are a part of and therefore have their face pointers changed on one side.
• Island edges and nodes may change containing faces. In the case of island edges this means that entire inner boundary components may change faces.

Because no topological changes are permitted at the unmoved end of the edge, this also precludes a loop edge being opened up or a non-loop edge being turned into a loop, and this will be trapped.

The edge to be moved must have different faces on each side. That means the edge is part of two face boundary components, at least one of which must be the outside boundary component of its face.

The node to which the end of the edge is moved must be located in one of the two boundary components of which the original edge is a part; that is, the node must be reachable in a trace starting with the edge's nextEdgeL or nextEdgeR. Note that it is possible for the two boundary components to be the inside and outside of the same component, in which case the destination node would be found in both.

Since no topological elements are allowed to be created or destroyed (or even modified in most cases), there are no changes to the relationships of features to topological elements as a result of this method.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

edgeID - the moved edge

sNodeID - the ID of the node from which the edge is detached (source node)

tNodeID - the ID of the node to which the edge is reattached (target node)

edgeCoords - an array of coordinates for the moved edge. The array must match the node coordinates at the new node and at the node at the other end, and be in the same sense as the old edge coordinates.

movedIsoNodes - allocate with default capacity; this method will fill it with the IDs of isolated nodes which change faces as a result of the move

movedIsoEdges - allocate with default capacity; this method will fill it with the IDs of isolated edges which change faces as a result of the move

allowIsoMoves - whether (true) or not (false) to allow an edge move operation that would cause any isolated nodes or edges to be in a different face. If such moves are allowed and if any do occur, the containing face information for such isolated nodes and edges is adjusted.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.lang.Exception

java.sql.SQLException

addEdge

public int addEdge(int node1,
                   int node2,
                   Point2DD[] coords)
            throws InvalidTopoOperationException,
                   TopoEntityNotFoundException,
                   java.sql.SQLException

Adds an Edge to the topology, making all necessary adjustments to the surrounding topological context. The shape points of the edge must place the edge totally inside a single face.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

node1 - the logical ID of the start node of the new edge

node2 - the logical ID of the end node of the new edge

coords - an array of points, including the endpoints (nodes), constituting the edge

Returns:

the logical ID of the added edge

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.sql.SQLException

addLoop

public int addLoop(int nodeID,
                   Point2DD[] coords)
            throws TopoEntityNotFoundException,
                   java.sql.SQLException,
                   InvalidTopoOperationException

Adds an edge that loops and connects to the same node. Can also be done by calling addEdge with node1=node2, which will wrap a call to this method.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

nodeID - the node to which the loop is to be connected

coords - array of points describing the loop, including the endpoints

Returns:

the logical ID of the added edge

Throws:

TopoEntityNotFoundException

java.sql.SQLException

InvalidTopoOperationException

addLinearGeometry

public int[] addLinearGeometry(JGeometry geom)
                        throws InvalidTopoOperationException,
                               java.sql.SQLException,
                               TopoEntityNotFoundException,
                               java.lang.Exception

Adds a linear (line string) geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph. Also will take a multiline string.

Returns an array of the edge IDs of the inserted and shared edges in sequence from the start to the end of the geometry. The coordinate order of all inserted edges is in the same sense as the input geometry and are returned positive, but there may be edges shared with the original topology that are listed in negative sense.

Parameters:

geom - an sdoapi geometry representing a single or multi- line-string in order from start to finish

Returns:

an array of edge IDs for the inserted and shared edges in order from start to finish of the geometry

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

addLinearGeometry

public int[] addLinearGeometry(Point2DD[] coords)
                        throws InvalidTopoOperationException,
                               java.sql.SQLException,
                               TopoEntityNotFoundException,
                               java.lang.Exception

Adds a linear (line string) geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph.

Returns an array of the edge IDs of the inserted and shared edges in sequence from the start to the end of the geometry. The coordinate order of all inserted edges is in the same sense as the input geometry and are returned positive, but there may be edges shared with the original topology that are listed in negative sense.

Parameters:

coords - an array of points representing a single line string in order from start to finish

Returns:

an array of edge IDs for the inserted and shared edges in order from start to finish of the line string

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

addPolygonGeometry

public int[] addPolygonGeometry(JGeometry geom)
                         throws InvalidTopoOperationException,
                                java.sql.SQLException,
                                TopoEntityNotFoundException,
                                java.lang.Exception

Adds a polygon geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the geometry with the edges and nodes in the topology graph. The geometry may be a polygon or multipolygon. Each polygon must have a single outer ring, which may contain any number of interior (island) rings.

Returns an array of the face IDs of all the faces which are contained inside any of the outer rings and are outside any inner rings.

The geometry may not intersect itself and this will be trapped.

Parameters:

geom - the geometry which must be one outer ring each with zero or more interior island rings

Returns:

an array of face IDs for all faces which together exactly cover the geometry excluding its island rings

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

addPolygonGeometry

public int[] addPolygonGeometry(Point2DD[] coords)
                         throws InvalidTopoOperationException,
                                java.sql.SQLException,
                                TopoEntityNotFoundException,
                                java.lang.Exception

Adds a single polygon geometry to the topology, inserting edges and nodes as necessary based on the full intersection of the polygon with the edges and nodes in the topology graph. Returns an array of the face IDs of all the faces which are contained inside the polygon.

The polygon must be stored counterclockwise. The polygon may not intersect itself and this will be trapped.

Parameters:

coords - an array of points representing the vertices of the polygon in counterclockwise order with the first vertex repeated in the last

Returns:

an array of face IDs for all faces which together exactly cover the polygon

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

removeObsoleteNodes

public boolean removeObsoleteNodes()
                            throws TopoEntityNotFoundException,
                                   java.sql.SQLException

Removes any nodes in the cache which are connected to two and only two distinct edges, are not assigned to point features, and do not serve as the demarcation between mismatched linear features. Small numbers of such nodes may result when addPolygonGeometry() is used to build a topology from the repeated insertion of polygons. They may also exist when edges have been removed during editing operations, leaving some unnecessary nodes.

Returns:

true if any nodes were removed; false otherwise

Throws:

TopoEntityNotFoundException

java.sql.SQLException

addPointGeometry

public int addPointGeometry(JGeometry geom)
                     throws InvalidTopoOperationException,
                            java.sql.SQLException,
                            TopoEntityNotFoundException,
                            java.lang.Exception

Adds a point geometry to the topology. If the point coincides with an existing node, no changes are made to the topology. Otherwise, an isolated node or a node splitting an edge is added to the topology.

Parameters:

geom - the geometry which represents the point

Returns:

the ID of the added or reused node

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

addPointGeometry

public int addPointGeometry(Point2DD coord)
                     throws InvalidTopoOperationException,
                            java.sql.SQLException,
                            TopoEntityNotFoundException,
                            java.lang.Exception

Adds a point to the topology. If the point coincides with an existing node, no changes are made to the topology. Otherwise, an isolated node or a node splitting an edge is added to the topology.

Parameters:

coord - the point

Returns:

the ID of the added or reused node

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

java.lang.Exception

changeEdgeCoords

public void changeEdgeCoords(int edge,
                             Point2DD[] coords)
                      throws InvalidTopoOperationException,
                             TopoEntityNotFoundException,
                             java.sql.SQLException

Replaces the coordinate string for an edge without changing the topological context of the edge. The only other changes this operation may require are: (1) the possible reassignments of island nodes and edges - this can only happen if the adjusted edge is a boundary between distinct faces; and (2) the adjustment of the MBRs of the faces on both sides, again only if they are distinct.

The changed edge coordinates cannot move the nodes at the endpoints. If that is desired, the edge must be deleted, the node(s) deleted (if permissible), and new node(s) and edge added, or you must use the moveNode() and/or moveEdge() methods.

The changed edge cannot reorder the node stars at the edge endpoints. The changed edge cannot be such as to reverse the faces on the left and right sides in the case of different faces on the two sides.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

edge - the edge ID of the edge to be spatially changed

coords - the new coordinates of the edge, including the node coordinates at both ends, which must match the existing node coordinates and therefore the terminal coordinates of the existing edge. The direction of the edge must also be preserved.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.sql.SQLException

changeEdgeCoords

public void changeEdgeCoords(int edge,
                             Point2DD[] coords,
                             java.util.ArrayList movedIsoNodes,
                             java.util.ArrayList movedIsoEdges,
                             boolean allowIsoMoves)
                      throws InvalidTopoOperationException,
                             TopoEntityNotFoundException,
                             java.sql.SQLException

Replaces the coordinate string for an edge without changing the topological context of the edge. There is one type of topological change permitted at the user's option: the possible reassignments of island nodes and edges - if the adjusted edge is a boundary between distinct faces. The adjustment of the MBRs of the faces on both sides, if distinct, will take place.

The changed edge coordinates cannot move the nodes at the endpoints. If that is desired, the edge must be deleted, the node(s) deleted (if permissible), and new node(s) and edge added, or you must use the moveEdge() and/or moveNode() methods.

The changed edge cannot reorder the node stars at the edge endpoints. The changed edge cannot be such as to reverse the faces on the left and right sides in the case of different faces on the two sides.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

edge - the edge ID of the edge to be spatially changed

coords - the new coordinates of the edge, including the node coordinates at both ends, which must match the existing node coordinates and therefore the terminal coordinates of the existing edge. The direction of the edge must also be preserved.

movedIsoNodes - allocate with default capacity; this method will fill it with the IDs of isolated nodes which change faces as a result of the change

movedIsoEdges - allocate with default capacity; this method will fill it with the IDs of isolated edges which change faces as a result of the change

allowIsoMoves - whether (true) or not (false) to allow the move of isolated entities, and to adjust edge coordinates and island reassignments as needed.

Throws:

InvalidTopoOperationException

TopoEntityNotFoundException

java.sql.SQLException

addNode

public int addNode(int edgeID,
                   Point2DD p,
                   int coordIndex,
                   boolean isNewShapePoint)
            throws TopoEntityNotFoundException,
                   InvalidTopoOperationException,
                   java.sql.SQLException

Adds a node to an edge, splitting the edge in the process. The split piece at the beginning of the old edge will carry the old edge ID.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

edgeID - the edge to be split by the added node (positive sense only)

p - the Point2DD representing the position of the added node

coordIndex - the index of the array position in the edge coord array on or after which the node is to be added (index is 0 for start)

isNewShapePoint - true if the added node is to be a new shape point following the indexed vertex of the edge; false if the added node is to be exactly on the exactly on the indexed vertex

Returns:

the logical ID of the added node

Throws:

TopoEntityNotFoundException

InvalidTopoOperationException

java.sql.SQLException

addIsolatedNode

public int addIsolatedNode(Point2DD p)
                    throws TopoEntityNotFoundException,
                           InvalidTopoOperationException,
                           java.sql.SQLException,
                           java.lang.Exception

Adds an isolated node inside of a face when the face ID is not known. If an Exception or any subclass but InvalidTopoOperation is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

p - coordinates of the node

Returns:

the logical ID of the added node

Throws:

TopoEntityNotFoundException

InvalidTopoOperationException

java.sql.SQLException

java.lang.Exception

addIsolatedNode

public int addIsolatedNode(int faceID,
                           Point2DD p)
                    throws TopoEntityNotFoundException,
                           InvalidTopoOperationException,
                           java.sql.SQLException

Adds an isolated node inside of a face when the face ID is known. If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

faceID - the logical ID of the face

p - coordinates of the node

Returns:

the logical ID of the added node

Throws:

TopoEntityNotFoundException

InvalidTopoOperationException

java.sql.SQLException

removeNode

public void removeNode(int nodeID)
                throws InvalidTopoOperationException,
                       java.sql.SQLException,
                       TopoEntityNotFoundException

Removes an isolated node or a node at the joining of two edges, merging the edges into one. An InvalidTopoOperationException is thrown if one or three or more edges meet at the node or if the positive and negative sense of same edge meet at node (a loop), if one or more point features are associated with the node, or if mismatched lineal features are assigned to the edges on either side.

If a SQLException is raised, the connection is rolled back (implicitly clearing the cache) before the exception is rethrown.

Parameters:

nodeID - the node to be removed

Throws:

InvalidTopoOperationException

java.sql.SQLException

TopoEntityNotFoundException

removeEdge

public void removeEdge(int edgeID)
                throws java.sql.SQLException,
                       TopoEntityNotFoundException,
                       InvalidTopoOperationException

Remove an edge, merging faces if there are different faces on each side of the edge.

If a linear feature is associated with the edge, if different area features are associated with the faces on the two sides in the merge face case, or if any portion of the edge is outside the editable window, an InvalidTopoOperationException is thrown. If the edge does not exist an InvalidTopoOperationException is also thrown. If any other exception is raised, the connection is rolled back (which implicitly clears the cache) before the exception is rethrown.

Parameters:

edgeID - the edge to be removed

Throws:

java.sql.SQLException

TopoEntityNotFoundException

InvalidTopoOperationException

validateCache

public boolean validateCache()
                      throws TopoValidationException,
                             TopoEntityNotFoundException,
                             java.sql.SQLException,
                             java.lang.Exception

Wrapper for validateCache(int level). Simply calls validateCache(1) to provide validation with full computational geometry checking.

Returns:

true if no errors encountered

Throws:

TopoValidationException

TopoEntityNotFoundException

java.sql.SQLException

java.lang.Exception

validateCache

public boolean validateCache(int level)
                      throws TopoValidationException,
                             TopoEntityNotFoundException,
                             java.sql.SQLException,
                             java.lang.Exception

Performs a topological validation of the cache, checking the consistency of all pointer relationships in the edge/node/face graph. At the user's option, also performs computational geometry checking. Note this is cache-only and will not reveal errors in the database topology outside the cache bounds. The method loadWindow() ensures that enough surrounding data is loaded into the cache for this method to perform validation.

Parameters:

level - whether to check computational geometry (0 or 1).

0 = without computational geometry: face trace closure including infinite loop trap; edge next/previous pointer consistency; edges meet at common nodes; island nodes point back to faces; all edges on a face boundary (inner and outer) link to the face.

1 = all of level 0, plus computational geometry: island entities are inside face outer boundary; no edge intersects itself or another edge; end coordinates of edges match node coordinates; node stars are properly ordered geometrically.

Returns:

true if no errors encountered

Throws:

TopoValidationException - if an error is found in any test

java.lang.Exception - if there is some missing data during computational geometry checks

TopoEntityNotFoundException - if some entity cannot be found and is pointed to by another entity

java.sql.SQLException

getContainingFace

public int getContainingFace(Point2DD p)
                      throws TopoEntityNotFoundException,
                             java.sql.SQLException,
                             java.lang.Exception

From the faces in the instance cache, determines the one, if any, that contains the test point in its open set. Processing includes islands; that is, the point must be in the open set excluding islands, not just inside the outer polygon.

If the point is exactly on an edge or node, NOID is returned. If a point is found not to be in any of the finite faces in the cache several situations exist for the return:
1. The whole topology has been cached -- returns UNIVERSE_FACE
2. A window has been loaded and:
a. The point is outside the window -- returns NOID
b. The point is inside the window -- returns UNIVERSE_FACE
3. Neither a window nor the whole topology has been loaded -- returns NOID

Parameters:

p - the test point.

Returns:

the face ID of the containing face.

Throws:

TopoEntityNotFoundException

java.sql.SQLException

java.lang.Exception

getNodeStarCount

public int getNodeStarCount(int nodeID)
                     throws TopoEntityNotFoundException

Gets a count of the number of edges connected at a node.

Returns:

the count; from 0 for an isolated node to any number

Throws:

TopoEntityNotFoundException

getNodeStar

public int[] getNodeStar(int nodeID)
                  throws TopoEntityNotFoundException

Gets an array of integers representing the IDs of a clockwise enumeration of all the edges connected to the given node. A positive edge ID represents an edge for which the node is its origin node. A negative edge ID represents an edge for which the node is its end node.

If there are loops connected to the node, edges may appear in the list twice with opposite signs.

Returns:

an integer array which is the clockwise list of edges

Throws:

TopoEntityNotFoundException

getNodeFaceStar

public int[] getNodeFaceStar(int nodeID)
                      throws TopoEntityNotFoundException,
                             java.sql.SQLException

Gets an array of integers representing the IDs of a clockwise enumeration of all the faces adjoining the given node. There will be one face returned for each edge connected to the node. For an isolated node, the containing face is returned. A face may appear more than once in the list.

Returns:

an integer array which is the clockwise list of faces

Throws:

TopoEntityNotFoundException

java.sql.SQLException

loadEdge

public Edge loadEdge(int id)
              throws TopoEntityNotFoundException,
                     InvalidTopoOperationException,
                     java.sql.SQLException

Loads an edge from the database if the edge is not already in the cache. If it is already in the cache, an InvalidTopoOperationException is thrown. If it is not in the database, a TopoEntityNotFoundException is thrown.

Returns:

the Edge object loaded.

Throws:

TopoEntityNotFoundException

InvalidTopoOperationException

java.sql.SQLException

loadNode

public Node loadNode(int id)
              throws TopoEntityNotFoundException,
                     java.sql.SQLException,
                     InvalidTopoOperationException

Loads a node from the database if the node is not already in the cache. If it is already in the cache, an InvalidTopoOperationException is thrown. If it is not in the database, a TopoEntityNotFoundException is thrown.

Returns:

the Node object loaded.

Throws:

TopoEntityNotFoundException

java.sql.SQLException

InvalidTopoOperationException

loadFace

public Face loadFace(int id)
              throws TopoEntityNotFoundException,
                     java.sql.SQLException,
                     InvalidTopoOperationException

Loads a face from the database if the face is not already in the cache. If it is already in the cache, an InvalidTopoOperationException is thrown. If it is not in the database, a TopoEntityNotFoundException is thrown.

Returns:

the Face object loaded.

Throws:

TopoEntityNotFoundException

java.sql.SQLException

InvalidTopoOperationException

main

public static void main(java.lang.String[] args)

getSrid

public int getSrid()

Returns the SRID of the topology.

Returns:

the SRID of the topology

getTopoTransactionID

public int getTopoTransactionID()

Returns the topology transaction ID if there is data loaded in the cache for update.

Returns:

the topology transaction ID for the editable cache. If the cache is not editable, returns 0.

getTopoName

public java.lang.String getTopoName()

Returns the name of the topology.

Returns:

the topology name

getIsEditable

public boolean getIsEditable()

Returns the editing state.

Returns:

isEditable

closeStmt

public void closeStmt()
               throws java.sql.SQLException

Closes the statement cursor.

Throws:

java.sql.SQLException - if a database error occurs

dispose

public void dispose()

Skip navigation links