org.apache.jackrabbit.core.nodetype
Class NodeTypeRegistry

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

All Implemented Interfaces:

NodeTypeEventListener, Dumpable

public class NodeTypeRegistry
extends Object
implements Dumpable, NodeTypeEventListener

A NodeTypeRegistry ...

Constructor Summary

protected

NodeTypeRegistry(NamespaceRegistry nsReg, FileSystem ntStore) Protected constructor

Method Summary

void	addListener(NodeTypeRegistryListener listener) Add a NodeTypeRegistryListener
protected void	checkForConflictingContent(QNodeTypeDefinition ntd) Checks whether there is existing content that would conflict with the given node type definition.
protected void	checkForReferencesInContent(Name 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.
void	externalRegistered(Collection<QNodeTypeDefinition> ntDefs) Called when one or more node types have been externally registered.
void	externalReregistered(QNodeTypeDefinition ntDef) Called when a node type has been externally re-registered.
void	externalUnregistered(Collection<Name> ntNames) Called when one or more node types have been externally unregistered.
Set<Name>	getDependentNodeTypes(Name nodeTypeName) Returns the names of those registered node types that have dependencies on the given node type.
EffectiveNodeType	getEffectiveNodeType(Name ntName)
EffectiveNodeType	getEffectiveNodeType(Name primary, Set<Name> mixins) Returns the effective node type of a node with the given primary and mixin types.
QNodeTypeDefinition	getNodeTypeDef(Name nodeTypeName) Returns the node type definition of the node type with the given name.
Name[]	getRegisteredNodeTypes() Returns the names of all registered node types.
QNodeDefinition	getRootNodeDef()
boolean	isBuiltIn(Name nodeTypeName)
boolean	isRegistered(Name 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(QNodeTypeDefinition ntd) Validates the NodeTypeDef and returns an EffectiveNodeType object representing the newly registered node type.
void	registerNodeTypes(Collection<QNodeTypeDefinition> ntDefs) Same as registerNodeType(QNodeTypeDefinition) except that a collection of NodeTypeDefs is registered instead of just one.
void	removeListener(NodeTypeRegistryListener listener) Remove a NodeTypeRegistryListener
EffectiveNodeType	reregisterNodeType(QNodeTypeDefinition ntd) Reregister a node type.
void	setEventChannel(NodeTypeEventChannel eventChannel) Set an event channel to inform about changes.
void	unregisterNodeType(Name ntName) Unregisters the specified node type.
void	unregisterNodeTypes(Collection<Name> ntNames) Same as unregisterNodeType(Name) 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 - name space registry

ntStore - store

Throws:

RepositoryException - if an error occurs

Method Detail

create

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

Create a new NodeTypeRegistry

Parameters:

nsReg - namespace registry

ntStore - node type store

Returns:

NodeTypeRegistry object

Throws:

RepositoryException - if an error occurs

getRegisteredNodeTypes

public Name[] getRegisteredNodeTypes()

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

Returns:

the names of all registered node types.

registerNodeType

public EffectiveNodeType registerNodeType(QNodeTypeDefinition 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 - if the given node type definition is invalid.

RepositoryException - if a repository error occurs.

registerNodeTypes

public void registerNodeTypes(Collection<QNodeTypeDefinition> ntDefs)
                       throws InvalidNodeTypeDefException,
                              RepositoryException

Same as registerNodeType(QNodeTypeDefinition) 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 QNodeTypeDefinition objects

Throws:

InvalidNodeTypeDefException - if the given node type definition is invalid.

RepositoryException - if a repository error occurs.

unregisterNodeTypes

public void unregisterNodeTypes(Collection<Name> ntNames)
                         throws NoSuchNodeTypeException,
                                RepositoryException

Same as unregisterNodeType(Name) 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 Name 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(Name)

unregisterNodeType

public void unregisterNodeType(Name 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(QNodeTypeDefinition ntd)
                                     throws NoSuchNodeTypeException,
                                            InvalidNodeTypeDefException,
                                            RepositoryException

Reregister a node type.

Parameters:

ntd - node type definition

Returns:

the new effective node type

Throws:

NoSuchNodeTypeException - if ntd refers to an unknown node type

InvalidNodeTypeDefException - if the node type definition is invalid

RepositoryException - if another error occurs

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(Name ntName)
                                       throws NoSuchNodeTypeException

Parameters:

ntName - name

Returns:

effective node type

Throws:

NoSuchNodeTypeException - if node type does not exist

getEffectiveNodeType

public EffectiveNodeType getEffectiveNodeType(Name primary,
                                              Set<Name> mixins)
                                       throws NodeTypeConflictException,
                                              NoSuchNodeTypeException

Returns the effective node type of a node with the given primary and mixin types.

Parameters:

primary - primary type of the node

mixins - mixin types of the node (set of names);

Returns:

effective node type

Throws:

NodeTypeConflictException - if the given types are conflicting

NoSuchNodeTypeException - if one of the given types is not found

getDependentNodeTypes

public Set<Name> getDependentNodeTypes(Name 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 Names

Throws:

NoSuchNodeTypeException - if node type does not exist

getNodeTypeDef

public QNodeTypeDefinition getNodeTypeDef(Name 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(Name nodeTypeName)

Parameters:

nodeTypeName - node type name

Returns:

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

isBuiltIn

public boolean isBuiltIn(Name nodeTypeName)

Parameters:

nodeTypeName - node type name

Returns:

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

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

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

externalRegistered

public void externalRegistered(Collection<QNodeTypeDefinition> ntDefs)
                        throws RepositoryException,
                               InvalidNodeTypeDefException

Called when one or more node types have been externally registered.

Specified by:

externalRegistered in interface NodeTypeEventListener

Parameters:

ntDefs - node type definitions

Throws:

RepositoryException - if an error occurs

InvalidNodeTypeDefException - if the node type definition is invalid

externalReregistered

public void externalReregistered(QNodeTypeDefinition ntDef)
                          throws NoSuchNodeTypeException,
                                 InvalidNodeTypeDefException,
                                 RepositoryException

Called when a node type has been externally re-registered.

Specified by:

externalReregistered in interface NodeTypeEventListener

Parameters:

ntDef - node type definition

Throws:

NoSuchNodeTypeException - if the node type had not yet been registered

InvalidNodeTypeDefException - if the node type definition is invalid

RepositoryException - if an error occurs

externalUnregistered

public void externalUnregistered(Collection<Name> ntNames)
                          throws RepositoryException,
                                 NoSuchNodeTypeException

Called when one or more node types have been externally unregistered.

Specified by:

externalUnregistered in interface NodeTypeEventListener

Parameters:

ntNames - node type qnames

Throws:

RepositoryException - if an error occurs

NoSuchNodeTypeException - if a node type is already unregistered

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 occurs 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 occurs 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 definitions to be persisted.

Throws:

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

checkForConflictingContent

protected void checkForConflictingContent(QNodeTypeDefinition 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(Name 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.

getRootNodeDef

public QNodeDefinition getRootNodeDef()

Returns:

the definition of the root node

setEventChannel

public void setEventChannel(NodeTypeEventChannel eventChannel)

Set an event channel to inform about changes.

Parameters:

eventChannel - event channel