Package org.apache.jackrabbit.core.nodetype

Class NodeTypeRegistry

    • Field Detail

      • disableCheckForReferencesInContentException

        public static volatile boolean disableCheckForReferencesInContentException
        Feature flag for the unfortunate behavior in Jackrabbit 2.1 and 2.2 where the exception from checkForReferencesInContent(Name) was never thrown because of a mistaken commit for JCR-2587. Setting this flag to true (the default value comes from the "disableCheckForReferencesInContentException" system property) will disable the exception thrown by default by the method.
        See Also:
        JCR-3223

    • Method Detail

      • 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.

      • 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, boolean)

      • 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

      • 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,
                                          NodeTypeDefDiff diff)
                                   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.
        diff -
        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