org.apache.jackrabbit.core.nodetype
Class NodeTypeRegistry

java.lang.Object
  org.apache.jackrabbit.core.nodetype.NodeTypeRegistry

All Implemented Interfaces:

Dumpable

public class NodeTypeRegistry

extends Object

implements Dumpable

A NodeTypeRegistry ...

Constructor Summary

protected

NodeTypeRegistry(NamespaceRegistry nsReg, FileSystem ntStore) Protected constructor

Method Summary

void	addListener(NodeTypeRegistryListener listener) Add a NodeTypeRegistryListener
protected void	checkForConflictingContent(NodeTypeDef ntd) Checks whether there is existing content that would conflict with the given node type definition.
protected void	checkForReferencesInContent(QName nodeTypeName) Checks whether there is existing content that directly or indirectly refers to the specified node type.
static NodeTypeRegistry	create(NamespaceRegistry nsReg, FileSystem ntStore) Create a new NodeTypeRegistry
void	dump(PrintStream ps) Dumps the state of this instance in a human readable format for diagnostic purposes.
Set	getDependentNodeTypes(QName nodeTypeName) Returns the names of those registered node types that have dependencies on the given node type.
EffectiveNodeType	getEffectiveNodeType(QName ntName)
EffectiveNodeType	getEffectiveNodeType(QName[] ntNames)
EffectiveNodeType	getEffectiveNodeType(QName[] ntNames, org.apache.jackrabbit.core.nodetype.EffectiveNodeTypeCache anEntCache, Map aRegisteredNTDefCache)
EffectiveNodeType	getEffectiveNodeType(QName ntName, org.apache.jackrabbit.core.nodetype.EffectiveNodeTypeCache anEntCache, Map aRegisteredNTDefCache)
NodeDef	getNodeDef(NodeDefId id)
NodeTypeDef	getNodeTypeDef(QName nodeTypeName) Returns the node type definition of the node type with the given name.
PropDef	getPropDef(PropDefId id)
QName[]	getRegisteredNodeTypes() Returns the names of all registered node types.
NodeDef	getRootNodeDef()
boolean	isBuiltIn(QName nodeTypeName)
boolean	isRegistered(QName nodeTypeName)
protected void	loadBuiltInNodeTypeDefs(NodeTypeDefStore store) Loads the built-in node type definitions into the given store.
protected void	loadCustomNodeTypeDefs(NodeTypeDefStore store) Loads the custom node type definitions into the given store.
protected void	persistCustomNodeTypeDefs(NodeTypeDefStore store) Persists the custom node type definitions contained in the given store.
EffectiveNodeType	registerNodeType(NodeTypeDef ntd) Validates the NodeTypeDef and returns an EffectiveNodeType object representing the newly registered node type.
void	registerNodeTypes(Collection ntDefs) Same as registerNodeType(NodeTypeDef) except that a collection of NodeTypeDefs is registered instead of just one.
void	removeListener(NodeTypeRegistryListener listener) Remove a NodeTypeRegistryListener
EffectiveNodeType	reregisterNodeType(NodeTypeDef ntd)
void	unregisterNodeType(QName ntName) Unregisters the specified node type.
void	unregisterNodeTypes(Collection ntNames) Same as unregisterNodeType(QName) except that a set of node types is unregistered instead of just one.

Methods inherited from class java.lang.Object

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

Constructor Detail

NodeTypeRegistry

protected NodeTypeRegistry(NamespaceRegistry nsReg,
                           FileSystem ntStore)
                    throws RepositoryException

Protected constructor

Parameters:

nsReg -

ntStore -

Throws:

RepositoryException

Method Detail

create

public static NodeTypeRegistry create(NamespaceRegistry nsReg,
                                      FileSystem ntStore)
                               throws RepositoryException

Create a new NodeTypeRegistry

Parameters:

nsReg -

ntStore -

Returns:

NodeTypeRegistry object

Throws:

RepositoryException

addListener

public void addListener(NodeTypeRegistryListener listener)

Add a NodeTypeRegistryListener

Parameters:

listener - the new listener to be informed on (un)registration of node types

removeListener

public void removeListener(NodeTypeRegistryListener listener)

Remove a NodeTypeRegistryListener

Parameters:

listener - an existing listener

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(QName ntName,
                                              org.apache.jackrabbit.core.nodetype.EffectiveNodeTypeCache anEntCache,
                                              Map aRegisteredNTDefCache)
                                       throws NoSuchNodeTypeException

Parameters:

ntName -

anEntCache -

aRegisteredNTDefCache -

Returns:

Throws:

NoSuchNodeTypeException

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(QName[] ntNames,
                                              org.apache.jackrabbit.core.nodetype.EffectiveNodeTypeCache anEntCache,
                                              Map aRegisteredNTDefCache)
                                       throws NodeTypeConflictException,
                                              NoSuchNodeTypeException

Parameters:

ntNames -

anEntCache -

aRegisteredNTDefCache -

Returns:

Throws:

NodeTypeConflictException

NoSuchNodeTypeException

getRegisteredNodeTypes

public QName[] getRegisteredNodeTypes()

Returns the names of all registered node types. That includes primary and mixin node types.

Returns:

the names of all registered node types.

getRootNodeDef

public NodeDef getRootNodeDef()

Returns:

the definition of the root node

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(QName ntName)
                                       throws NoSuchNodeTypeException

Parameters:

ntName -

Returns:

Throws:

NoSuchNodeTypeException

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(QName[] ntNames)
                                       throws NodeTypeConflictException,
                                              NoSuchNodeTypeException

Parameters:

ntNames -

Returns:

Throws:

NodeTypeConflictException

NoSuchNodeTypeException

registerNodeType

public EffectiveNodeType registerNodeType(NodeTypeDef ntd)
                                   throws InvalidNodeTypeDefException,
                                          RepositoryException

Validates the NodeTypeDef and returns an EffectiveNodeType object representing the newly registered node type.

The validation includes the following checks:

• Supertypes must exist and be registered
• Inheritance graph must not be circular
• Aggregation of supertypes must not result in name conflicts, ambiguities, etc.
• Definitions of auto-created properties must specify a name
• Default values in property definitions must satisfy value constraints specified in the same property definition
• Definitions of auto-created child-nodes must specify a name
• Default node type in child-node definitions must exist and be registered
• The aggregation of the default node types in child-node definitions must not result in name conflicts, ambiguities, etc.
• Definitions of auto-created child-nodes must not specify default node types which would lead to infinite child node creation (e.g. node type 'A' defines auto-created child node with default node type 'A' ...)
• Node types specified as constraints in child-node definitions must exist and be registered
• The aggregation of the node types specified as constraints in child-node definitions must not result in name conflicts, ambiguities, etc.
• Default node types in child-node definitions must satisfy node type constraints specified in the same child-node definition

Parameters:

ntd - the definition of the new node type

Returns:

an EffectiveNodeType instance

Throws:

InvalidNodeTypeDefException

RepositoryException

registerNodeTypes

public void registerNodeTypes(Collection ntDefs)
                       throws InvalidNodeTypeDefException,
                              RepositoryException

Same as registerNodeType(NodeTypeDef) except that a collection of NodeTypeDefs is registered instead of just one.

This method can be used to register a set of node types that have dependencies on each other.

Parameters:

ntDefs - a collection of NodeTypeDef objects

Throws:

InvalidNodeTypeDefException

RepositoryException

unregisterNodeTypes

public void unregisterNodeTypes(Collection ntNames)
                         throws NoSuchNodeTypeException,
                                RepositoryException

Same as unregisterNodeType(QName) except that a set of node types is unregistered instead of just one.

This method can be used to unregister a set of node types that depend on each other.

Parameters:

ntNames - a collection of QName objects denoting the node types to be unregistered

Throws:

NoSuchNodeTypeException - if any of the specified names does not denote a registered node type.

RepositoryException - if another error occurs

See Also:

unregisterNodeType(QName)

unregisterNodeType

public void unregisterNodeType(QName ntName)
                        throws NoSuchNodeTypeException,
                               RepositoryException

Unregisters the specified node type. In order for a node type to be successfully unregistered it must meet the following conditions:

1. the node type must obviously be registered.
2. a built-in node type can not be unregistered.
3. the node type must not have dependents, i.e. other node types that are referencing it.
4. the node type must not be currently used by any workspace.

Parameters:

ntName - name of the node type to be unregistered

Throws:

NoSuchNodeTypeException - if ntName does not denote a registered node type.

RepositoryException - if another error occurs.

See Also:

unregisterNodeTypes(Collection)

reregisterNodeType

public EffectiveNodeType reregisterNodeType(NodeTypeDef ntd)
                                     throws NoSuchNodeTypeException,
                                            InvalidNodeTypeDefException,
                                            RepositoryException

Parameters:

ntd -

Returns:

Throws:

NoSuchNodeTypeException

InvalidNodeTypeDefException

RepositoryException

getDependentNodeTypes

public Set getDependentNodeTypes(QName nodeTypeName)
                          throws NoSuchNodeTypeException

Returns the names of those registered node types that have dependencies on the given node type.

Parameters:

nodeTypeName - node type name

Returns:

a set of node type QNames

Throws:

NoSuchNodeTypeException

getNodeTypeDef

public NodeTypeDef getNodeTypeDef(QName nodeTypeName)
                           throws NoSuchNodeTypeException

Returns the node type definition of the node type with the given name.

Parameters:

nodeTypeName - name of node type whose definition should be returned.

Returns:

the node type definition of the node type with the given name.

Throws:

NoSuchNodeTypeException - if a node type with the given name does not exist

isRegistered

public boolean isRegistered(QName nodeTypeName)

Parameters:

nodeTypeName -

Returns:

true if the specified node type is registered; false otherwise.

isBuiltIn

public boolean isBuiltIn(QName nodeTypeName)

Parameters:

nodeTypeName -

Returns:

true if the specified node type is built-in; false otherwise.

getNodeDef

public NodeDef getNodeDef(NodeDefId id)

Parameters:

id -

Returns:

the node definition for the given id.

getPropDef

public PropDef getPropDef(PropDefId id)

Parameters:

id -

Returns:

the property definition for the given id.

dump

public void dump(PrintStream ps)

Dumps the state of this instance in a human readable format for diagnostic purposes.

Specified by:

dump in interface Dumpable

Parameters:

ps - stream to dump state to

loadBuiltInNodeTypeDefs

protected void loadBuiltInNodeTypeDefs(NodeTypeDefStore store)
                                throws RepositoryException

Loads the built-in node type definitions into the given store.

This method may be overridden by extensions of this class; It must only be called once and only from within the constructor though.

Parameters:

store - The NodeTypeDefStore into which the node type definitions are loaded.

Throws:

RepositoryException - If an error occurrs while loading the built-in node type definitions.

loadCustomNodeTypeDefs

protected void loadCustomNodeTypeDefs(NodeTypeDefStore store)
                               throws RepositoryException

Loads the custom node type definitions into the given store.

This method may be overridden by extensions of this class; It must only be called once and only from within the constructor though.

Parameters:

store - The NodeTypeDefStore into which the node type definitions are loaded.

Throws:

RepositoryException - If an error occurrs while loading the custom node type definitions.

persistCustomNodeTypeDefs

protected void persistCustomNodeTypeDefs(NodeTypeDefStore store)
                                  throws RepositoryException

Persists the custom node type definitions contained in the given store.

Parameters:

store - The NodeTypeDefStore containing the definitons to be persisted.

Throws:

RepositoryException - If an error occurrs while persisting the custom node type definitions.

checkForConflictingContent

protected void checkForConflictingContent(NodeTypeDef ntd)
                                   throws RepositoryException

Checks whether there is existing content that would conflict with the given node type definition.

This method is not implemented yet and always throws a RepositoryException.

TODO

1. apply deep locks on root nodes in every workspace or alternatively put repository in 'exclusive' or 'single-user' mode
2. check if the given node type (or any node type that has dependencies on this node type) is currently referenced by nodes in the repository.
3. check if applying the changed definitions to the affected items would violate existing node type constraints
4. apply and persist changes to affected nodes (e.g. update definition id's, etc.)

   the above checks/actions are absolutely necessary in order to guarantee integrity of repository content.

   Parameters:

   ntd - The node type definition replacing the former node type definition of the same name.

   Throws:

   RepositoryException - If there is conflicting content or if the check failed for some other reason.

checkForReferencesInContent

protected void checkForReferencesInContent(QName nodeTypeName)
                                    throws RepositoryException

Checks whether there is existing content that directly or indirectly refers to the specified node type.

This method is not implemented yet and always throws a RepositoryException.

TODO:

1. apply deep locks on root nodes in every workspace or alternatively put repository in 'single-user' mode
2. check if the given node type is currently referenced by nodes in the repository.
3. remove the node type if it is not currently referenced, otherwise throw exception

   the above checks are absolutely necessary in order to guarantee integrity of repository content.

   Parameters:

   nodeTypeName - The name of the node type to be checked.

   Throws:

   RepositoryException - If the specified node type is currently being referenced or if the check failed for some other reason.