Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.modeshape.graph.session
Class GraphSession<Payload,PropertyPayload>

    java.lang.Object
      org.modeshape.graph.session.GraphSession<Payload,PropertyPayload>

Type Parameters:
  `Payload` - the type of the payload object for each node, used to allow the nodes to hold additional cached information
  `PropertyPayload` - the type of payload object for each property, used to allow the nodes to hold additional cached information

    @NotThreadSafe
    public class GraphSession<Payload,PropertyPayload>

extends Object

This class represents an interactive session for working with the content within a graph. This session maintains a cache of content read from the repository, as well as transient changes that have been made to the nodes within this session that are then pushed to the graph when the session is `saved`.

Like the other Graph APIs, the mutable objects in this session should not be held onto for very long periods of time. When the session is `saved` or {`refreshed` (or when a node is `saved` or `refreshed`), the session may `unload` and discard some of its nodes. Using nodes after they are discarded may result in assertion errors (assuming Java assertions are enabled).

Nested Class Summary
`static interface` | `GraphSession.Authorizer`
`protected static class` | `GraphSession.Dependencies`
`protected class` | `GraphSession.LoadAllChildrenVisitor` A visitor that ensures that all children of a node are loaded, and provides a hook to `post-process the parent`.
`protected class` | `GraphSession.LoadNodesVisitor` An abstract base class for visitors that need to load nodes using a single batch for all read operations.
`static class` | `GraphSession.Node<Payload,PropertyPayload>`
`static class` | `GraphSession.NodeId` An immutable identifier for a node, used within the `GraphSession`.
`static interface` | `GraphSession.NodeIdFactory`
`static class` | `GraphSession.NodeOperations<Payload,PropertyPayload>` A default implementation of `GraphSession.Operations` that provides all the basic functionality required by a graph session.
`static class` | `GraphSession.NodeVisitor<NodePayload,PropertyPayloadType>` The node visitor.
`protected static class` | `GraphSession.NoOpAuthorizer` `GraphSession.Authorizer` implementation that does nothing.
`static interface` | `GraphSession.Operations<NodePayload,PropertyPayload>`
`static class` | `GraphSession.PropertyInfo<PropertyPayload>`
`protected static class` | `GraphSession.RefreshState<Payload,PropertyPayload>`
`protected static class` | `GraphSession.Snapshot<PropertyPayload>`
`static class` | `GraphSession.Status`
`static class` | `GraphSession.StructureSnapshot<PropertyPayload>` A read-only visitor that walks the cache to obtain a snapshot of the cache structure.

Field Summary
`protected GraphSession.Authorizer` | `authorizer`
`protected Map<GraphSession.NodeId,GraphSession.Dependencies>` | `changeDependencies` A map that records how the changes to a node are dependent upon other nodes.
`protected ExecutionContext` | `context`
`protected Set<UUID>` | `deletedNodes` A set that records the UUIDs of the nodes that have been deleted from this session (via the `operations`) but not yet `saved`.
`protected GraphSession.NodeIdFactory` | `idFactory`
`protected int` | `loadDepth`
`protected ListMultimap<Name,GraphSession.Node<Payload,PropertyPayload>>` | `NO_CHILDREN`
`protected Map<Name,GraphSession.PropertyInfo<PropertyPayload>>` | `NO_PROPERTIES`
`protected GraphSession.Operations<Payload,PropertyPayload>` | `nodeOperations`
`protected Map<GraphSession.NodeId,GraphSession.Node<Payload,PropertyPayload>>` | `nodes` A map of the nodes keyed by their identifier.
`protected Map<UUID,GraphSession.Node<Payload,PropertyPayload>>` | `nodesByUuid` A utility map of the nodes keyed by their UUID.
`protected Graph.Batch` | `operations`
`protected PathFactory` | `pathFactory`
`protected GraphSession.Node<Payload,PropertyPayload>` | `root`
`protected Graph` | `store`
`protected String` | `workspaceName`

Constructor Summary
`GraphSession(Graph graph, String workspaceName, GraphSession.Operations<Payload,PropertyPayload> nodeOperations)` Create a session that uses the supplied graph and the supplied node operations.
`GraphSession(Graph graph, String workspaceName, GraphSession.Operations<Payload,PropertyPayload> nodeOperations, GraphSession.Authorizer authorizer)` Create a session that uses the supplied graph and the supplied node operations.

Method Summary
`void` | `clearAllChangedNodes()` Remove any cached information that has been marked as a transient change.
`protected void` | `clearNodes()`
`protected GraphSession.Node<Payload,PropertyPayload>` | `createNode(GraphSession.Node<Payload,PropertyPayload> parent, GraphSession.NodeId nodeId, Location location)`
`GraphSession.Node<Payload,PropertyPayload>` | `findNodeRelativeTo(GraphSession.Node<Payload,PropertyPayload> startingPoint, Path relativePath)` Find the node with the supplied path relative to another node.
`protected GraphSession.Node<Payload,PropertyPayload>` | `findNodeRelativeTo(GraphSession.Node<Payload,PropertyPayload> startingPoint, Path relativePath, boolean loadIfRequired)` Find the node with the supplied path relative to another node.
`GraphSession.Node<Payload,PropertyPayload>` | `findNodeWith(GraphSession.NodeId id)` Find in the session the node with the supplied identifier.
`GraphSession.Node<Payload,PropertyPayload>` | `findNodeWith(GraphSession.NodeId id, Path path)` Find the node with the supplied identifier or, if no such node is found, the node at the supplied path.
`GraphSession.Node<Payload,PropertyPayload>` | `findNodeWith(Location location)` Find in the session the node with the supplied location.
`GraphSession.Node<Payload,PropertyPayload>` | `findNodeWith(Path path)` Find the node with the supplied path.
`protected GraphSession.Node<Payload,PropertyPayload>` | `findNodeWith(Path path, boolean loadIfRequired)` Find the node with the supplied path.
`protected long` | `getCurrentTime()`
`int` | `getDepthForLoadingNodes()` Get the subgraph depth that is read when a node is loaded from the persistence store.
`PathFactory` | `getPathFactory()` Get the path factory that should be used to adjust the path objects.
`GraphSession.Node<Payload,PropertyPayload>` | `getRoot()` Get the root node.
`boolean` | `hasPendingChanges()` Returns whether the session cache has any pending changes that need to be executed.
`void` | `immediateClone(Path source, String sourceWorkspace, Path destination, boolean removeExisting, boolean destPathIncludesSegment)` Clone the supplied source branch and place into the destination location, optionally removing any existing copy that already exists in the destination location, doing so immediately without enqueuing the operation within the session's operations.
`void` | `immediateCopy(Path source, Path destination)` Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the current workspace, doing so immediately without enqueuing the operation within the session's operations.
`Location` | `immediateCopy(Path source, String sourceWorkspace, Path destination)` Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the current workspace, doing so immediately without enqueuing the operation within the session's operations.
`Location` | `immediateCreateOrReplace(Path path, Collection<Property> properties)` Create a new node at the supplied location, appending to any existing node at that path.
`void` | `immediateMove(Path nodeToMove, Path destination)` Move this node from its current location so that is is a child of the supplied parent, doing so immediately without enqueuing the operation within the session's operations.
`protected GraphSession.Node<Payload,PropertyPayload>` | `node(GraphSession.NodeId id)`
`protected GraphSession.Node<Payload,PropertyPayload>` | `node(UUID uuid)`
`protected Graph.Batch` | `operations()`
`protected void` | `put(GraphSession.Node<Payload,PropertyPayload> node)`
`protected void` | `recordDelete(GraphSession.Node<Payload,PropertyPayload> node)` Record the fact that the supplied node is in the process of being deleted, so any cached information (outside of the node object itself) should be cleaned up.
`protected void` | `recordMove(GraphSession.Node<Payload,PropertyPayload> nodeBeingMoved, GraphSession.Node<Payload,PropertyPayload> oldParent, GraphSession.Node<Payload,PropertyPayload> newParent)`
`protected void` | `recordUnloaded(GraphSession.Node<Payload,PropertyPayload> node)` Record the fact that the supplied node is in the process of being unloaded, so any cached information (outside of the node object itself) should be cleaned up.
`void` | `refresh(boolean keepChanges)` Refreshes (removes the cached state) for all cached nodes.
`void` | `refresh(GraphSession.Node<Payload,PropertyPayload> node, boolean keepChanges)` Refreshes (removes the cached state) for the given node and its descendants.
`void` | `refresh(Path path, boolean keepChanges)` Refreshes (removes the cached state) for the given node and its descendants.
`void` | `refreshProperties(GraphSession.Node<Payload,PropertyPayload> node)` Refreshes all properties for the given node only.
`protected void` | `removeNode(GraphSession.NodeId id)`
`void` | `save()` Save any changes that have been accumulated by this session.
`void` | `save(GraphSession.Node<Payload,PropertyPayload> node)` Save any changes to the identified node or its descendants.
`void` | `setDepthForLoadingNodes(int depth)` Set the loading depth parameter, which controls how deep a subgraph should be read when a node is loaded from the persistence store.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### NO_CHILDREN

    protected final ListMultimap<Name,GraphSession.Node<Payload,PropertyPayload>> NO_CHILDREN

### NO_PROPERTIES

    protected final Map<Name,GraphSession.PropertyInfo<PropertyPayload>> NO_PROPERTIES

### authorizer

    protected final GraphSession.Authorizer authorizer

### context

    protected final ExecutionContext context

### store

    protected final Graph store

### root

    protected final GraphSession.Node<Payload,PropertyPayload> root

### nodeOperations

    protected final GraphSession.Operations<Payload,PropertyPayload> nodeOperations

### pathFactory

    protected final PathFactory pathFactory

### idFactory

    protected final GraphSession.NodeIdFactory idFactory

### workspaceName

    protected final String workspaceName

### loadDepth

    protected int loadDepth

### nodes

    protected final Map<GraphSession.NodeId,GraphSession.Node<Payload,PropertyPayload>> nodes

  A map of the nodes keyed by their identifier. This map contains all of the nodes and is the normative

### nodesByUuid

    protected final Map<UUID,GraphSession.Node<Payload,PropertyPayload>> nodesByUuid

  A utility map of the nodes keyed by their UUID. This map will not contain nodes that have no UUIDs.

### changeDependencies

    protected final Map<GraphSession.NodeId,GraphSession.Dependencies> changeDependencies

  A map that records how the changes to a node are dependent upon other nodes.

### deletedNodes

    protected final Set<UUID> deletedNodes

  A set that records the UUIDs of the nodes that have been deleted from this session (via the `operations`) but not yet `saved`. This is used to know whether a node has been locally removed to prevent reloading the node from the persistent store.

### operations

    protected Graph.Batch operations

Constructor Detail

### GraphSession

    public GraphSession(Graph graph,
                        String workspaceName,
                        GraphSession.Operations<Payload,PropertyPayload> nodeOperations)

  Create a session that uses the supplied graph and the supplied node operations.

  Parameters:
    `graph` - the graph that this session is to use
    `workspaceName` - the name of the workspace that is to be used, or null if the current workspace should be used
    `nodeOperations` - the operations that are to be performed during various stages in the lifecycle of a node, or null if there are no special operations that should be performed

### GraphSession

    public GraphSession(Graph graph,
                        String workspaceName,
                        GraphSession.Operations<Payload,PropertyPayload> nodeOperations,
                        GraphSession.Authorizer authorizer)

  Create a session that uses the supplied graph and the supplied node operations.

  Parameters:
    `graph` - the graph that this session is to use
    `workspaceName` - the name of the workspace that is to be used, or null if the current workspace should be used
    `nodeOperations` - the operations that are to be performed during various stages in the lifecycle of a node, or null if there are no special operations that should be performed
    `authorizer` - the authorizing component, or null if no special authorization is to be performed
  Throws:
    `IllegalArgumentException` - if the graph reference is null
    `IllegalArgumentException` - if the depth is not positive

Method Detail

### put

    protected void put(GraphSession.Node<Payload,PropertyPayload> node)

### node

    protected GraphSession.Node<Payload,PropertyPayload> node(GraphSession.NodeId id)

### node

    protected GraphSession.Node<Payload,PropertyPayload> node(UUID uuid)

### removeNode

    protected void removeNode(GraphSession.NodeId id)

### clearNodes

    protected void clearNodes()

### operations

    protected Graph.Batch operations()

### getDepthForLoadingNodes

    public int getDepthForLoadingNodes()

  Get the subgraph depth that is read when a node is loaded from the persistence store. By default, this value is 1.

  Returns:
    the loading depth; always positive

### setDepthForLoadingNodes

    public void setDepthForLoadingNodes(int depth)

  Set the loading depth parameter, which controls how deep a subgraph should be read when a node is loaded from the persistence store. By default, this value is 1.

  Parameters:
    `depth` - the depth that should be read whenever a single node is loaded
  Throws:
    `IllegalArgumentException` - if the depth is not positive

### getRoot

    public GraphSession.Node<Payload,PropertyPayload> getRoot()

  Get the root node.

  Returns:
    the root node; never null

### getPathFactory

    public PathFactory getPathFactory()

  Get the path factory that should be used to adjust the path objects.

  Returns:
    the path factory; never null

### findNodeWith

    public GraphSession.Node<Payload,PropertyPayload> findNodeWith(Location location)
                                                            throws PathNotFoundException,
                                                                   AccessControlException

  Find in the session the node with the supplied location. If the location does not have a path, this method must first query the actual persistent store, even if the session already has loaded the node. Thus, this method may not be the most efficient technique to find a node.

  Parameters:
    `location` - the location of the node
  Returns:
    the cached node at the supplied location
  Throws:
    `PathNotFoundException` - if the node at the supplied location does not exist
    `AccessControlException` - if the user does not have permission to read the node given by the supplied location
    `IllegalArgumentException` - if the location is null

### findNodeWith

    public GraphSession.Node<Payload,PropertyPayload> findNodeWith(GraphSession.NodeId id)

  Find in the session the node with the supplied identifier.

  Parameters:
    `id` - the identifier of the node
  Returns:
    the identified node, or null if the session has no node with the supplied identifier
  Throws:
    `IllegalArgumentException` - if the identifier is null

### findNodeWith

    public GraphSession.Node<Payload,PropertyPayload> findNodeWith(GraphSession.NodeId id,
                                                                   Path path)
                                                            throws PathNotFoundException,
                                                                   AccessControlException

  Find the node with the supplied identifier or, if no such node is found, the node at the supplied path. Note that if a node was found by the identifier, the resulting may not have the same path as that supplied as a parameter.

  Parameters:
    `id` - the identifier to the node; may be null if the node is to be found by path
    `path` - the path that should be used to find the node only when the cache doesn't contain a node with the identifier
  Returns:
    the node with the supplied id and/or path
  Throws:
    `IllegalArgumentException` - if the identifier and path are both node
    `PathNotFoundException` - if the node at the supplied path does not exist
    `AccessControlException` - if the user does not have permission to read the nodes given by the supplied path

### findNodeWith

    public GraphSession.Node<Payload,PropertyPayload> findNodeWith(Path path)
                                                            throws PathNotFoundException,
                                                                   AccessControlException

  Find the node with the supplied path. This node quickly finds the node if it exists in the cache, or if it is not in the cache, it loads the nodes down the supplied path.

  Parameters:
    `path` - the path to the node
  Returns:
    the node information
  Throws:
    `PathNotFoundException` - if the node at the supplied path does not exist
    `AccessControlException` - if the user does not have permission to read the nodes given by the supplied path

### findNodeWith

    protected GraphSession.Node<Payload,PropertyPayload> findNodeWith(Path path,
                                                                      boolean loadIfRequired)
                                                               throws PathNotFoundException,
                                                                      AccessControlException

  Find the node with the supplied path. This node quickly finds the node if it exists in the cache, or if it is not in the cache, it loads the nodes down the supplied path. However, if `loadIfRequired` is `false`, then any node along the path that is not loaded will result in this method returning null.

  Parameters:
    `path` - the path to the node
    `loadIfRequired` - true if any missing nodes should be loaded, or false if null should be returned if any nodes along the path are not loaded
  Returns:
    the node information
  Throws:
    `PathNotFoundException` - if the node at the supplied path does not exist
    `AccessControlException` - if the user does not have permission to read the nodes given by the supplied path

### findNodeRelativeTo

    public GraphSession.Node<Payload,PropertyPayload> findNodeRelativeTo(GraphSession.Node<Payload,PropertyPayload> startingPoint,
                                                                         Path relativePath)
                                                                  throws PathNotFoundException,
                                                                         AccessControlException

  Find the node with the supplied path relative to another node. This node quickly finds the node by walking the supplied relative path starting at the supplied node. As soon as a cached node is found to not be fully loaded, the persistent information for that node and all remaining nodes along the relative path are read from the persistent store and inserted into the cache.

  Parameters:
    `startingPoint` - the node from which the path is relative
    `relativePath` - the relative path from the designated starting point to the desired node; may not be null and may not be an `absolute` path
  Returns:
    the node information
  Throws:
    `PathNotFoundException` - if the node at the supplied path does not exist
    `AccessControlException` - if the user does not have permission to read the nodes given by the supplied path

### findNodeRelativeTo

    protected GraphSession.Node<Payload,PropertyPayload> findNodeRelativeTo(GraphSession.Node<Payload,PropertyPayload> startingPoint,
                                                                            Path relativePath,
                                                                            boolean loadIfRequired)
                                                                     throws PathNotFoundException,
                                                                            AccessControlException

  Find the node with the supplied path relative to another node. This node quickly finds the node by walking the supplied relative path starting at the supplied node. As soon as a cached node is found to not be fully loaded, the persistent information for that node and all remaining nodes along the relative path are read from the persistent store and inserted into the cache.

  Parameters:
    `startingPoint` - the node from which the path is relative
    `relativePath` - the relative path from the designated starting point to the desired node; may not be null and may not be an `absolute` path
    `loadIfRequired` - true if any missing nodes should be loaded, or false if null should be returned if any nodes along the path are not loaded
  Returns:
    the node information, or null if the node was not yet loaded (and `loadRequired` was false)
  Throws:
    `PathNotFoundException` - if the node at the supplied path does not exist
    `AccessControlException` - if the user does not have permission to read the nodes given by the supplied path

### hasPendingChanges

    public boolean hasPendingChanges()

  Returns whether the session cache has any pending changes that need to be executed.

  Returns:
    true if there are pending changes, or false if there is currently no changes

### clearAllChangedNodes

    public void clearAllChangedNodes()

  Remove any cached information that has been marked as a transient change.

### immediateMove

    public void immediateMove(Path nodeToMove,
                              Path destination)
                       throws AccessControlException,
                              RepositorySourceException

  Move this node from its current location so that is is a child of the supplied parent, doing so immediately without enqueuing the operation within the session's operations. The current session is modified immediately to reflect the move result.

  Parameters:
    `nodeToMove` - the path to the node that is to be moved; may not be null
    `destination` - the desired new path; may not be null
  Throws:
    `IllegalArgumentException` - if the node being moved is the root node
    `AccessControlException` - if the caller does not have the permission to perform the operation
    `RepositorySourceException` - if any error resulting while performing the operation

### immediateCopy

    public void immediateCopy(Path source,
                              Path destination)
                       throws AccessControlException,
                              RepositorySourceException

  Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the current workspace, doing so immediately without enqueuing the operation within the session's operations. The current session is modified immediately to reflect the copy result.

  Note that the destination path should not include a same-name-sibling index, since this will be ignored and will always be recomputed (as the copy will be appended to any children already in the destination's parent).

  Parameters:
    `source` - the path to the node that is to be copied; may not be null
    `destination` - the path where the copy is to be placed; may not be null
  Throws:
    `IllegalArgumentException` - either path is null or invalid
    `AccessControlException` - if the caller does not have the permission to perform the operation
    `RepositorySourceException` - if any error resulting while performing the operation

### immediateCopy

    public Location immediateCopy(Path source,
                                  String sourceWorkspace,
                                  Path destination)
                           throws InvalidWorkspaceException,
                                  AccessControlException,
                                  PathNotFoundException,
                                  RepositorySourceException

  Copy the node at the supplied source path in the named workspace, and place the copy at the supplied location within the current workspace, doing so immediately without enqueuing the operation within the session's operations. The current session is modified immediately to reflect the copy result.

  Note that the destination path should not include a same-name-sibling index, since this will be ignored and will always be recomputed (as the copy will be appended to any children already in the destination's parent).

  Parameters:
    `source` - the path to the node that is to be copied; may not be null
    `sourceWorkspace` - the name of the workspace where the source node is to be found, or null if the current workspace should be used
    `destination` - the path where the copy is to be placed; may not be null
  Returns:
    the location of the copy
  Throws:
    `IllegalArgumentException` - either path is null or invalid
    `PathNotFoundException` - if the node being copied or the parent of the destination path do not exist
    `InvalidWorkspaceException` - if the source workspace name is invalid or does not exist
    `AccessControlException` - if the caller does not have the permission to perform the operation
    `RepositorySourceException` - if any error resulting while performing the operation

### immediateCreateOrReplace

    public Location immediateCreateOrReplace(Path path,
                                             Collection<Property> properties)
                                      throws AccessControlException,
                                             RepositorySourceException

  Create a new node at the supplied location, appending to any existing node at that path.

  Parameters:
    `path` - the path where the new node should be created
    `properties` - the properties to be added to the node; may be null or empty
  Returns:
    the location of the new node
  Throws:
    `AccessControlException` - if the caller does not have the permission to perform the operation
    `RepositorySourceException` - if any error resulting while performing the operation

### immediateClone

    public void immediateClone(Path source,
                               String sourceWorkspace,
                               Path destination,
                               boolean removeExisting,
                               boolean destPathIncludesSegment)
                        throws InvalidWorkspaceException,
                               AccessControlException,
                               UuidAlreadyExistsException,
                               PathNotFoundException,
                               RepositorySourceException

  Clone the supplied source branch and place into the destination location, optionally removing any existing copy that already exists in the destination location, doing so immediately without enqueuing the operation within the session's operations. The current session is modified immediately to reflect the clone result.

  Parameters:
    `source` - the path to the node that is to be cloned; may not be null
    `sourceWorkspace` - the name of the workspace where the source node is to be found, or null if the current workspace should be used
    `destination` - the path for the new cloned copy; may not be null index
    `removeExisting` - true if the original should be removed, or false if the original should be left
    `destPathIncludesSegment` - true if the destination path includes the segment that should be used
  Throws:
    `IllegalArgumentException` - either path is null or invalid
    `InvalidWorkspaceException` - if the source workspace name is invalid or does not exist
    `UuidAlreadyExistsException` - if copy could not be completed because the current workspace already includes at least one of the nodes at or below the `source` branch in the source workspace
    `PathNotFoundException` - if the node being clone or the destination node do not exist
    `AccessControlException` - if the caller does not have the permission to perform the operation
    `RepositorySourceException` - if any error resulting while performing the operation

### refresh

    public void refresh(boolean keepChanges)
                 throws InvalidStateException,
                        RepositorySourceException

  Refreshes (removes the cached state) for all cached nodes.

  If `keepChanges == true`, modified nodes will not have their state refreshed, while all others will either be unloaded or changed to reflect the current state of the persistent store.

  Parameters:
    `keepChanges` - indicates whether changed nodes should be kept or refreshed from the repository.
  Throws:
    `InvalidStateException` - if any error resulting while reading information from the repository
    `RepositorySourceException` - if any error resulting while reading information from the repository

### refresh

    public void refresh(Path path,
                        boolean keepChanges)
                 throws InvalidStateException,
                        RepositorySourceException

  Refreshes (removes the cached state) for the given node and its descendants. This method does nothing If the node is not in the cache.

  If `keepChanges == true`, modified nodes will not have their state refreshed, while all others will either be unloaded or changed to reflect the current state of the persistent store.

  Parameters:
    `path` - the path to the node that is to be refreshed; may not be null
    `keepChanges` - indicates whether changed nodes should be kept or refreshed from the repository.
  Throws:
    `InvalidStateException` - if any error resulting while reading information from the repository
    `RepositorySourceException` - if any error resulting while reading information from the repository

### refresh

    public void refresh(GraphSession.Node<Payload,PropertyPayload> node,
                        boolean keepChanges)
                 throws InvalidStateException,
                        RepositorySourceException

  Refreshes (removes the cached state) for the given node and its descendants.

  If `keepChanges == true`, modified nodes will not have their state refreshed, while all others will either be unloaded or changed to reflect the current state of the persistent store.

  Parameters:
    `node` - the node that is to be refreshed; may not be null
    `keepChanges` - indicates whether changed nodes should be kept or refreshed from the repository.
  Throws:
    `InvalidStateException` - if any error resulting while reading information from the repository
    `RepositorySourceException` - if any error resulting while reading information from the repository

### refreshProperties

    public void refreshProperties(GraphSession.Node<Payload,PropertyPayload> node)
                           throws InvalidStateException,
                                  RepositorySourceException

  Refreshes all properties for the given node only. This refresh always discards changed properties.

  This method is not recursive and will not modify or access any descendants of the given node.

  NOTE: Calling this method on a node that already has modified properties can result in the enqueued property changes overwriting the current properties on a save() call. This method should be used with great care to avoid this situation.

  Parameters:
    `node` - the node for which the properties are to be refreshed; may not be null
  Throws:
    `InvalidStateException` - if the node is new
    `RepositorySourceException` - if any error resulting while reading information from the repository

### save

    public void save()
              throws PathNotFoundException,
                     ValidationException,
                     InvalidStateException

  Save any changes that have been accumulated by this session.

  Throws:
    `PathNotFoundException` - if the state of this session is invalid and is attempting to change a node that doesn't exist
    `ValidationException` - if any of the changes being made result in an invalid node state
    `InvalidStateException` - if the supplied node is no longer a node within this cache (because it was unloaded)

### save

    public void save(GraphSession.Node<Payload,PropertyPayload> node)
              throws PathNotFoundException,
                     ValidationException,
                     InvalidStateException

  Save any changes to the identified node or its descendants. The supplied node may not have been deleted or created in this session since the last save operation.

  Parameters:
    `node` - the node being saved; may not be null
  Throws:
    `PathNotFoundException` - if the state of this session is invalid and is attempting to change a node that doesn't exist
    `ValidationException` - if any of the changes being made result in an invalid node state
    `InvalidStateException` - if the supplied node is no longer a node within this cache (because it was unloaded)

### createNode

    protected GraphSession.Node<Payload,PropertyPayload> createNode(GraphSession.Node<Payload,PropertyPayload> parent,
                                                                    GraphSession.NodeId nodeId,
                                                                    Location location)

### getCurrentTime

    protected long getCurrentTime()

### recordMove

    protected void recordMove(GraphSession.Node<Payload,PropertyPayload> nodeBeingMoved,
                              GraphSession.Node<Payload,PropertyPayload> oldParent,
                              GraphSession.Node<Payload,PropertyPayload> newParent)

### recordDelete

    protected void recordDelete(GraphSession.Node<Payload,PropertyPayload> node)

  Record the fact that the supplied node is in the process of being deleted, so any cached information (outside of the node object itself) should be cleaned up.

  Parameters:
    `node` - the node being deleted; never null

### recordUnloaded

    protected void recordUnloaded(GraphSession.Node<Payload,PropertyPayload> node)

  Record the fact that the supplied node is in the process of being unloaded, so any cached information (outside of the node object itself) should be cleaned up.

  Parameters:
    `node` - the node being unloaded; never null

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2008-2012 JBoss, a division of Red Hat. All Rights Reserved.