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

## org.modeshape.jcr
Class SystemContent

    java.lang.Object
      org.modeshape.jcr.SystemContent

    public class SystemContent

extends Object

Field Summary
`static String` | `GENERATED_PREFIX`
`protected static Pattern` | `GENERATED_PREFIX_PATTERN`

Method Summary
`protected Iterable<?>` | `all(CachedNode node, Name propertyName)`
`SessionCache` | `cache()`
`void` | `cleanUpLocks(Set<String> activeSessionIds)` Clean up the locks within the repository's system content.
`protected Object` | `first(CachedNode node, Name propertyName)`
`protected Object` | `first(CachedNode node, Name propertyName, Object defaultValue)`
`boolean` | `hasVersionHistory(NodeKey versionableNodeKey)`
`protected MutableCachedNode` | `initializeVersionStorage(NodeKey versionableNodeKey, NodeKey versionHistoryKey, NodeKey versionKey, Name primaryTypeName, Set<Name> mixinTypeNames, Path versionHistoryPath, NodeKey originalVersionKey, DateTime now)` Create and initialize the version history structure for a versionable node with the supplied UUID.
`protected NodeKey` | `keyForNamespaceUri(String namespaceUri)`
`NodeKey` | `locksKey()`
`CachedNode` | `locksNode()`
`MutableCachedNode` | `mutableLocksNode()`
`MutableCachedNode` | `mutableNamespacesNode()`
`MutableCachedNode` | `mutableNodeTypesNode()`
`MutableCachedNode` | `mutableVersionStorageNode()`
`NodeKey` | `namespacesKey()`
`CachedNode` | `namespacesNode()`
`protected Name` | `nextNameForVersionNode(CachedNode historyNode, Property predecessors, ChildReferences historyChildren)` Compute the name for the next version node in the given history.
`NodeKey` | `nodeTypesKey()`
`CachedNode` | `nodeTypesNode()`
`protected int` | `propertyType(Object value)`
`Collection<NamespaceRegistry.Namespace>` | `readAllNamespaces()`
`List<NodeTypeDefinition>` | `readAllNodeTypes()` Read from system storage all of the node type definitions.
`protected NodeDefinition` | `readChildNodeDefinition(CachedNode childDefn)`
`String` | `readNamespacePrefix(String namespaceUri, boolean generateIfMissing)`
`NodeTypeDefinition` | `readNodeTypeDefinition(CachedNode nodeType)`
`List<NodeTypeDefinition>` | `readNodeTypes(Set<Name> nodeTypesToRefresh)` Read from system storage the node type definitions with the supplied names.
`protected PropertyDefinition` | `readPropertyDefinition(CachedNode propDefn)`
`MutableCachedNode` | `recordNewVersion(CachedNode versionableNode, SessionCache cacheForVersionableNode, Path versionHistoryPath, NodeKey originalVersionKey, Collection<Property> versionableProperties, DateTime now, AtomicReference<MutableCachedNode> frozenNodeOutput)` The method efficiently updates the JCR version history and storage with a new version of a node being checked in.
`Set<String>` | `registerNamespaces(Map<String,String> newUrisByPrefix)`
`void` | `save()`
`void` | `store(Iterable<org.modeshape.jcr.JcrNodeType> nodeTypes, boolean updateExisting)` Stores the node types in the system area under `/jcr:system/jcr:nodeTypes`.
`void` | `store(org.modeshape.jcr.JcrNodeType nodeType, boolean updateExisting)` Stores the node type in the system area under `/jcr:system/jcr:nodeTypes`.
`NodeKey` | `systemKey()`
`CachedNode` | `systemNode()`
`boolean` | `unregisterNamespace(String namespaceUri)`
`NodeKey` | `versionHistoryNodeKeyFor(NodeKey versionableNodeKey)`
`NodeKey` | `versionStorageKey()`
`CachedNode` | `versionStorageNode()`

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

Field Detail

### GENERATED_PREFIX

    public static final String GENERATED_PREFIX

See Also:
  Constant Field Values

### GENERATED_PREFIX_PATTERN

    protected static final Pattern GENERATED_PREFIX_PATTERN

Method Detail

### save

    public void save()

### cache

    public final SessionCache cache()

### systemKey

    public NodeKey systemKey()

### nodeTypesKey

    public NodeKey nodeTypesKey()

### namespacesKey

    public NodeKey namespacesKey()

### locksKey

    public NodeKey locksKey()

### versionStorageKey

    public NodeKey versionStorageKey()

### systemNode

    public CachedNode systemNode()

### nodeTypesNode

    public CachedNode nodeTypesNode()

### namespacesNode

    public CachedNode namespacesNode()

### locksNode

    public CachedNode locksNode()

### versionStorageNode

    public CachedNode versionStorageNode()

### mutableNodeTypesNode

    public MutableCachedNode mutableNodeTypesNode()

### mutableNamespacesNode

    public MutableCachedNode mutableNamespacesNode()

### mutableLocksNode

    public MutableCachedNode mutableLocksNode()

### mutableVersionStorageNode

    public MutableCachedNode mutableVersionStorageNode()

### store

    public void store(Iterable<org.modeshape.jcr.JcrNodeType> nodeTypes,
                      boolean updateExisting)

  Stores the node types in the system area under `/jcr:system/jcr:nodeTypes`.

  For each node type, a node is created with primary type of `nt:nodeType` and a name that corresponds to the node type's name. All other properties and child nodes for the newly created node are added in a manner consistent with the guidance provided in section 6.7.22 of the JCR 1.0 specification and section 4.7.24 of the JCR 2.0 specification where possible.

  Parameters:
    `nodeTypes` - the node types to write out; may not be null
    `updateExisting` - a boolean flag denoting whether the new node type definition should be overwrite an existing node type definition

### store

    public void store(org.modeshape.jcr.JcrNodeType nodeType,
                      boolean updateExisting)

  Stores the node type in the system area under `/jcr:system/jcr:nodeTypes`.

  The stored content will contain a node with a primary type of `nt:nodeType` and a name that corresponds to the node type's name. All other properties and child nodes for the newly created node are added in a manner consistent with the guidance provided in section 6.7.22 of the JCR 1.0 specification and section 4.7.24 of the JCR 2.0 specification where possible.

  Parameters:
    `nodeType` - the node type to write; may not be null
    `updateExisting` - a boolean flag denoting whether the new node type definition should be overwrite an existing node type definition

### readNodeTypes

    public List<NodeTypeDefinition> readNodeTypes(Set<Name> nodeTypesToRefresh)

  Read from system storage the node type definitions with the supplied names.

  Parameters:
    `nodeTypesToRefresh` -
  Returns:
    the node types as read from the system storage

### readAllNodeTypes

    public List<NodeTypeDefinition> readAllNodeTypes()

  Read from system storage all of the node type definitions.

  Returns:
    the node types as read from the system storage

### readNodeTypeDefinition

    public NodeTypeDefinition readNodeTypeDefinition(CachedNode nodeType)

### readPropertyDefinition

    protected PropertyDefinition readPropertyDefinition(CachedNode propDefn)
                                                 throws ConstraintViolationException

  Throws:
    `ConstraintViolationException`

### readChildNodeDefinition

    protected NodeDefinition readChildNodeDefinition(CachedNode childDefn)
                                              throws ConstraintViolationException

  Throws:
    `ConstraintViolationException`

### propertyType

    protected final int propertyType(Object value)

### all

    protected final Iterable<?> all(CachedNode node,
                                    Name propertyName)

### first

    protected final Object first(CachedNode node,
                                 Name propertyName)

### first

    protected final Object first(CachedNode node,
                                 Name propertyName,
                                 Object defaultValue)

### readAllNamespaces

    public Collection<NamespaceRegistry.Namespace> readAllNamespaces()

### registerNamespaces

    public Set<String> registerNamespaces(Map<String,String> newUrisByPrefix)

### readNamespacePrefix

    public String readNamespacePrefix(String namespaceUri,
                                      boolean generateIfMissing)

### unregisterNamespace

    public boolean unregisterNamespace(String namespaceUri)

### keyForNamespaceUri

    protected final NodeKey keyForNamespaceUri(String namespaceUri)

### cleanUpLocks

    public void cleanUpLocks(Set<String> activeSessionIds)

  Clean up the locks within the repository's system content. Any locks held by active sessions are extended/renewed, while those locks that are significantly expired are removed.

  Parameters:
    `activeSessionIds` - the IDs of the sessions that are still active in this repository

### versionHistoryNodeKeyFor

    public NodeKey versionHistoryNodeKeyFor(NodeKey versionableNodeKey)

### hasVersionHistory

    public boolean hasVersionHistory(NodeKey versionableNodeKey)

### initializeVersionStorage

    protected MutableCachedNode initializeVersionStorage(NodeKey versionableNodeKey,
                                                         NodeKey versionHistoryKey,
                                                         NodeKey versionKey,
                                                         Name primaryTypeName,
                                                         Set<Name> mixinTypeNames,
                                                         Path versionHistoryPath,
                                                         NodeKey originalVersionKey,
                                                         DateTime now)

  Create and initialize the version history structure for a versionable node with the supplied UUID. This method assumes that the version history node does not exist.

  Given a NodeKey for a node that has an identifier part of "fae2b929-c5ef-4ce5-9fa1-514779ca0ae3", the SHA-1 hash of this identifier part is "b46dde8905f76361779339fa3ccacc4f47664255". The path to the version history for this node is as follows:

        + jcr:system
          + jcr:versionStorage   {jcr:primaryType = mode:versionStorage}
            + b4   {jcr:primaryType = mode:versionHistoryFolder}
              + 6d   {jcr:primaryType = mode:versionHistoryFolder}
                + de   {jcr:primaryType = mode:versionHistoryFolder}
                  + 298905f76361779339fa3ccacc4f47664255   {jcr:primaryType = nt:versionHistory}
                    + jcr:versionLabels  {jcr:primaryType = nt:versionLabels}
                    + jcr:rootVersion  {jcr:primaryType = nt:version}
                      - jcr:uuid = ...
                      - jcr:created = ...
                      + jcr:frozenNode  {jcr:primaryType = nt:frozenNode}
                        - jcr:frozenUuid
                        - jcr:frozenPrimaryType
                        - jcr:frozenMixinTypes

  Note that the path between "/jcr:system/jcr:versionStorage" and the "nt:versionHistory" node is shown as being `hiearchical`.

  Parameters:
    `versionableNodeKey` - the identifier of the versionable node for which the history is to be created; may not be null
    `versionHistoryKey` - the key to the version history node; may not be null
    `versionKey` - the key to be used for the initial version; may be null if the key should be generated
    `primaryTypeName` - the name of the primary type of the versionable node; may not be null
    `mixinTypeNames` - the names of the mixin types for the versionable node; may be null or empty
    `versionHistoryPath` - the path of the version history node; may not be null
    `originalVersionKey` - the key of the original node from which the new versionable node was copied; may be null
    `now` - the current date time; may not be null
  Returns:
    the history node; never null

### recordNewVersion

    public MutableCachedNode recordNewVersion(CachedNode versionableNode,
                                              SessionCache cacheForVersionableNode,
                                              Path versionHistoryPath,
                                              NodeKey originalVersionKey,
                                              Collection<Property> versionableProperties,
                                              DateTime now,
                                              AtomicReference<MutableCachedNode> frozenNodeOutput)

  The method efficiently updates the JCR version history and storage with a new version of a node being checked in. However, it does not update the versionable node with the "mix:versionable" properties.

  Note that this method will initialize the version history for the node if the version history does not already exist.

  The names of the different versions has changed since 2.x, and now follows the same convention and algorithm as used in the reference implementation. See `nextNameForVersionNode(org.modeshape.jcr.cache.CachedNode, org.modeshape.jcr.value.Property, org.modeshape.jcr.cache.ChildReferences)` for details.

  Parameters:
    `versionableNode` - the versionable node for which a new version is to be created in the node's version history; may not be null
    `cacheForVersionableNode` - the cache used to access the versionable node and any descendants; may not be null
    `versionHistoryPath` - the path of the version history node; may not be null
    `originalVersionKey` - the key of the original node from which the new versionable node was copied; may be null
    `versionableProperties` - the versionable node's properties that should be record in the version history (on the frozen node); may be null or empty
    `now` - the current date time; may not be null
    `frozenNodeOutput` - the reference that should be set upon successful completion to the frozen node created under the new version; may not be null
  Returns:
    the version node in the version history; never null

### nextNameForVersionNode

    protected Name nextNameForVersionNode(CachedNode historyNode,
                                          Property predecessors,
                                          ChildReferences historyChildren)

  Compute the name for the next version node in the given history. Note that the naming convention has changed since 2.x, and now follows the same convention and algorithm as used in the reference implementation. See org.apache.jackrabbit.core.version.InternalVersionManagerBase.calculateCheckinVersionName(...) for the original.

  The basic rules are as follows:

  - first the predecessor version with the shortest name is searched.
  - if that predecessor version is the root version, the new version gets the name "{number of successors}+1" + ".0"
  - if that predecessor version has no successor, the last digit of it's version number is incremented.
  - if that predecessor version has successors but the incremented name does not exist, that name is used.
  - otherwise a ".0" is added to the name until a non conflicting name is found.
    Example Graph:

         jcr:rootVersion
          |     |
         1.0   2.0
          |
         1.1
          |
         1.2 ---\  ------\
          |      \        \
         1.3   1.2.0   1.2.0.0
          |      |
         1.4   1.2.1 ----\
          |      |        \
         1.5   1.2.2   1.2.1.0
          |      |        |
         1.6     |     1.2.1.1
          |------/
         1.7

  Parameters:
    `historyNode` -
    `predecessors` - the 'jcr:predecessors' property; may not be null
    `historyChildren` - the child references under the version history for the node
  Returns:
    the next name

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Alpha5
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.