vendor/jackalope/jackalope/src/Jackalope/NodeType/NodeTypeManager.php line 113

Open in your IDE?
  1. <?php
  3. namespace Jackalope\NodeType;
  5. use Iterator;
  6. use IteratorAggregate;
  7. use ArrayIterator;
  8. use PHPCR\AccessDeniedException;
  9. use PHPCR\NamespaceException;
  10. use PHPCR\NamespaceRegistryInterface;
  11. use PHPCR\NodeType\NodeTypeInterface;
  12. use PHPCR\NodeType\NodeTypeDefinitionInterface;
  13. use PHPCR\NodeType\NodeTypeManagerInterface;
  14. use PHPCR\NodeType\NoSuchNodeTypeException;
  15. use PHPCR\NodeType\NodeTypeExistsException;
  16. use Jackalope\ObjectManager;
  17. use Jackalope\NotImplementedException;
  18. use Jackalope\FactoryInterface;
  19. use PHPCR\RepositoryException;
  21. /**
  22.  * {@inheritDoc}
  23.  *
  24.  * In Jackalope, we try to do lazy fetching of node types to reduce overhead.
  25.  * Jackalope supports registering node types, and when using the jackrabbit for
  26.  * transport, there is an additional method registerNodeTypesCnd for the
  27.  * jackrabbit specific textual node type specification.
  28.  *
  29.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  30.  * @license http://opensource.org/licenses/MIT MIT License
  31.  */
  32. class NodeTypeManager implements IteratorAggregate, NodeTypeManagerInterface
  33. {
  34.     /**
  35.      * The factory to instantiate objects.
  36.      *
  37.      * @var FactoryInterface
  38.      */
  39.     protected $factory;
  41.     /**
  42.      * @var ObjectManager
  43.      */
  44.     protected $objectManager;
  46.     /**
  47.      * @var NamespaceRegistryInterface
  48.      */
  49.     protected $namespaceRegistry;
  51.     /**
  52.      * Cache of already fetched primary node type instances.
  53.      *
  54.      * @var array
  55.      */
  56.     protected $primaryTypes;
  58.     /**
  59.      * Cache of already fetched mixin node type instances.
  60.      *
  61.      * @var array
  62.      */
  63.     protected $mixinTypes;
  65.     /**
  66.      * Array of arrays with the super type as key and its sub types as values.
  67.      * @var array
  68.      */
  69.     protected $nodeTree = [];
  71.     /**
  72.      * Flag to only load all node types from the backend once.
  73.      *
  74.      * Methods like hasNodeType() need to fetch all node types. Others like
  75.      * getNodeType() do not need all, but just the requested one. Unless we
  76.      * need all, we only load specific ones and cache them.
  77.      *
  78.      * @var boolean
  79.      */
  80.     protected $fetchedAllFromBackend = false;
  82.     /**
  83.      * Create the node type manager for a session.
  84.      *
  85.      * There may be only one instance per session
  86.      * @param FactoryInterface  $factory
  87.      * @param ObjectManager     $objectManager
  88.      * @param NamespaceRegistryInterface $namespaceRegistry
  89.      */
  90.     public function __construct(
  91.         FactoryInterface $factory,
  92.         ObjectManager $objectManager,
  93.         NamespaceRegistryInterface $namespaceRegistry
  94.     ) {
  95.         $this->factory = $factory;
  96.         $this->objectManager = $objectManager;
  97.         $this->namespaceRegistry = $namespaceRegistry;
  98.     }
  100.     /**
  101.      * Fetch a node type from backend.
  102.      *
  103.      * Without a filter parameter, this will fetch all node types from the backend.
  104.      *
  105.      * It is no problem to call this method with null as name, it will remember
  106.      * once it fetched all node types and do nothing after that.
  107.      *
  108.      * On fetch all, already cached node types are kept.
  109.      *
  110.      * @param string $name type name to fetch. defaults to null which will
  111.      *      fetch all nodes.
  112.      */
  113.     protected function fetchNodeTypes($name = null)
  114.     {
  115.         if ($this->fetchedAllFromBackend) {
  116.             return;
  117.         }
  119.         if (null !== $name) {
  120.             if (!empty($this->primaryTypes[$name]) || !empty($this->mixinTypes[$name])) {
  121.                 return; //we already know this node
  122.             }
  124.             //OPTIMIZE: also avoid trying to fetch nonexisting definitions we already tried to get
  125.             $nodeTypes = $this->objectManager->getNodeType($name);
  126.         } else {
  127.             $nodeTypes = $this->objectManager->getNodeTypes();
  128.             $this->fetchedAllFromBackend = true;
  129.         }
  131.         foreach ($nodeTypes as $nodeType) {
  132.             /** @var NodeType $nodeType */
  133.             $nodeType = $this->factory->get(NodeType::class, [$this, $nodeType]);
  134.             $name = $nodeType->getName();
  135.             //do not overwrite existing types. maybe they where changed locally
  136.             if (empty($this->primaryTypes[$name]) && empty($this->mixinTypes[$name])) {
  137.                 $this->addNodeType($nodeType);
  138.             }
  139.         }
  140.     }
  142.     /**
  143.      * Stores the node type in our internal structures (flat && tree)
  144.      *
  145.      * @param NodeTypeInterface $nodeType The nodetype to add
  146.      */
  147.     protected function addNodeType(NodeTypeInterface $nodeType)
  148.     {
  149.         if ($nodeType->isMixin()) {
  150.             $this->mixinTypes[$nodeType->getName()] = $nodeType;
  151.         } else {
  152.             $this->primaryTypes[$nodeType->getName()] = $nodeType;
  153.         }
  154.         $this->addToNodeTree($nodeType);
  155.     }
  157.     /**
  158.      * Helper method for node types: Returns the declared subtypes of a given
  159.      * nodename.
  160.      *
  161.      * @param string $nodeTypeName
  162.      *
  163.      * @return array with the names of the subnode types pointing to the node type instances
  164.      *
  165.      * @see NodeType::getDeclaredSubtypes
  166.      *
  167.      * @private
  168.      */
  169.     public function getDeclaredSubtypes($nodeTypeName)
  170.     {
  171.         // OPTIMIZE: any way to avoid loading all nodes at this point?
  172.         $this->fetchNodeTypes();
  174.         if (empty($this->nodeTree[$nodeTypeName])) {
  175.             return [];
  176.         }
  178.         return $this->nodeTree[$nodeTypeName];
  179.     }
  181.     /**
  182.      * Helper method for NodeType: Returns all sub types of a node and their
  183.      * sub types.
  184.      *
  185.      * @param string $nodeTypeName
  186.      *
  187.      * @return array with the names of the subnode types pointing to the node type instances
  188.      *
  189.      * @see NodeType::getSubtypes
  190.      *
  191.      * @private
  192.      */
  193.     public function getSubtypes($nodeTypeName)
  194.     {
  195.         // OPTIMIZE: any way to avoid loading all nodes at this point?
  196.         $this->fetchNodeTypes();
  197.         $ret = [];
  198.         if (isset($this->nodeTree[$nodeTypeName])) {
  199.             foreach ($this->nodeTree[$nodeTypeName] as $name => $subnode) {
  200.                 $ret = array_merge($ret, [$name => $subnode], $this->getSubtypes($name));
  201.             }
  202.         }
  204.         return $ret;
  205.     }
  207.     /**
  208.      * Adds the declared super types of a node type to the tree to be able to
  209.      * fetch the sub types of those super types later on.
  210.      *
  211.      * Part of addNodeType.
  212.      *
  213.      * @param NodeTypeInterface $nodetype the node type to add.
  214.      */
  215.     private function addToNodeTree($nodetype)
  216.     {
  217.         foreach ($nodetype->getDeclaredSupertypeNames() as $declaredSupertypeName) {
  218.             if (isset($this->nodeTree[$declaredSupertypeName])) {
  219.                 $this->nodeTree[$declaredSupertypeName] =
  220.                     array_merge(
  221.                         $this->nodeTree[$declaredSupertypeName],
  222.                         [$nodetype->getName() => $nodetype]
  223.                     );
  224.             } else {
  225.                 $this->nodeTree[$declaredSupertypeName] = [$nodetype->getName() => $nodetype];
  226.             }
  227.         }
  228.     }
  230.     /**
  231.      * {@inheritDoc}
  232.      *
  233.      * @api
  234.      */
  235.     public function getNodeType($nodeTypeName)
  236.     {
  237.         if (null === $nodeTypeName) {
  238.             throw new NoSuchNodeTypeException('nodeTypeName is <null>');
  239.         }
  241.         if ('' === $nodeTypeName) {
  242.             throw new NoSuchNodeTypeException('nodeTypeName is empty string');
  243.         }
  245.         if ($nodeTypeName[0] === '{') {
  246.             list($uri, $name) = explode('}', substr($nodeTypeName, 1));
  247.             $prefix = $this->namespaceRegistry->getPrefix($uri);
  248.             $nodeTypeName = "$prefix:$name";
  249.         }
  251.         $this->fetchNodeTypes($nodeTypeName);
  253.         if (isset($this->primaryTypes[$nodeTypeName])) {
  254.             return $this->primaryTypes[$nodeTypeName];
  255.         }
  257.         if (isset($this->mixinTypes[$nodeTypeName])) {
  258.             return $this->mixinTypes[$nodeTypeName];
  259.         }
  261.         throw new NoSuchNodeTypeException($nodeTypeName);
  262.     }
  264.     /**
  265.      * {@inheritDoc}
  266.      *
  267.      * @api
  268.      */
  269.     public function hasNodeType($name)
  270.     {
  271.         try {
  272.             $this->fetchNodeTypes($name);
  273.         } catch (NoSuchNodeTypeException $e) {
  274.             // if we have not yet fetched all types and this type is not existing
  275.             // we get an exception. just ignore the exception, we don't have the type.
  276.             return false;
  277.         }
  279.         return isset($this->primaryTypes[$name]) || isset($this->mixinTypes[$name]);
  280.     }
  282.     /**
  283.      * {@inheritDoc}
  284.      *
  285.      * @api
  286.      */
  287.     public function getAllNodeTypes()
  288.     {
  289.         $this->fetchNodeTypes();
  291.         return new ArrayIterator(array_merge($this->primaryTypes, $this->mixinTypes));
  292.     }
  294.     /**
  295.      * {@inheritDoc}
  296.      *
  297.      * @api
  298.      */
  299.     public function getPrimaryNodeTypes()
  300.     {
  301.         $this->fetchNodeTypes();
  303.         return new ArrayIterator($this->primaryTypes);
  304.     }
  306.     /**
  307.      * {@inheritDoc}
  308.      *
  309.      * @api
  310.      */
  311.     public function getMixinNodeTypes()
  312.     {
  313.         $this->fetchNodeTypes();
  315.         return new ArrayIterator($this->mixinTypes);
  316.     }
  318.     /**
  319.      * {@inheritDoc}
  320.      *
  321.      * @api
  322.      */
  323.     public function createNodeTypeTemplate($ntd = null)
  324.     {
  325.         return $this->factory->get(NodeTypeTemplate::class, [$this, $ntd]);
  326.     }
  328.     /**
  329.      * {@inheritDoc}
  330.      *
  331.      * @api
  332.      */
  333.     public function createNodeDefinitionTemplate()
  334.     {
  335.         return $this->factory->get(NodeDefinitionTemplate::class, [$this]);
  336.     }
  338.     /**
  339.      * {@inheritDoc}
  340.      *
  341.      * @api
  342.      */
  343.     public function createPropertyDefinitionTemplate()
  344.     {
  345.         return $this->factory->get(PropertyDefinitionTemplate::class, [$this]);
  346.     }
  348.     /**
  349.      * {@inheritDoc}
  350.      *
  351.      * @api
  352.      */
  353.     public function registerNodeType(NodeTypeDefinitionInterface $ntd, $allowUpdate)
  354.     {
  355.         $this->registerNodeTypes([$ntd], $allowUpdate);
  357.         return $ntd;
  358.     }
  360.     /**
  361.      * Internally create a node type object
  362.      *
  363.      * @param NodeTypeDefinitionInterface $ntd
  364.      * @param bool                        $allowUpdate whether updating the definition is to be allowed or not
  365.      *
  366.      * @return NodeType the new node type
  367.      *
  368.      * @throws RepositoryException
  369.      * @throws NodeTypeExistsException
  370.      */
  371.     protected function createNodeType(NodeTypeDefinitionInterface $ntd, $allowUpdate)
  372.     {
  373.         if ($this->hasNodeType($ntd->getName()) && !$allowUpdate) {
  374.             throw new NodeTypeExistsException('NodeType already existing: '.$ntd->getName());
  375.         }
  377.         return $this->factory->get(NodeType::class, [$this, $ntd]);
  378.     }
  380.     /**
  381.      * {@inheritDoc}
  382.      *
  383.      * @api
  384.      */
  385.     public function registerNodeTypes(array $definitions, $allowUpdate)
  386.     {
  387.         $nts = [];
  389.         // prepare them first (all or nothing)
  390.         foreach ($definitions as $definition) {
  391.             $nts[$definition->getName()] = $this->createNodeType($definition, $allowUpdate);
  392.         }
  394.         $this->objectManager->registerNodeTypes($definitions, $allowUpdate);
  396.         // no need to fetch the node types as with cnd, we already have the def and can
  397.         // now register them ourselves
  398.         foreach ($nts as $nt) {
  399.             $this->addNodeType($nt);
  400.         }
  402.         return new ArrayIterator($nts);
  403.     }
  405.     /**
  406.      * {@inheritDoc}
  407.      *
  408.      * @throws AccessDeniedException
  409.      * @throws NamespaceException
  410.      *
  411.      * @api
  412.      */
  413.     public function registerNodeTypesCnd($cnd, $allowUpdate)
  414.     {
  415.         //set fetched from backend to false to allow to load the new types from backend
  416.         $fetched = $this->fetchedAllFromBackend;
  417.         $this->fetchedAllFromBackend = false;
  418.         $this->objectManager->registerNodeTypesCnd($cnd, $allowUpdate);
  420.         //parse out type names and fetch types to return definitions of the new nodes
  421.         preg_match_all('/\[([^\]]*)\]/', $cnd, $names);
  422.         $types = [];
  423.         foreach ($names[1] as $name) {
  424.             $types[$name] = $this->getNodeType($name);
  425.         }
  426.         $this->fetchedAllFromBackend = $fetched;
  428.         return $types;
  429.     }
  431.     /**
  432.      * {@inheritDoc}
  433.      *
  434.      * @api
  435.      */
  436.     public function unregisterNodeType($name)
  437.     {
  438.         if (!empty($this->primaryTypes[$name])) {
  439.             unset($this->primaryTypes[$name]);
  440.         } elseif (!empty($this->mixinTypes[$name])) {
  441.             unset($this->mixinTypes[$name]);
  442.         } else {
  443.             throw new NoSuchNodeTypeException('NodeType not found: '.$name);
  444.         }
  446.         throw new NotImplementedException('TODO: remove from nodeTree and register with server (jackrabbit has not implemented this yet)');
  447.     }
  449.     /**
  450.      * {@inheritDoc}
  451.      *
  452.      * @api
  453.      */
  454.     public function unregisterNodeTypes(array $names)
  455.     {
  456.         foreach ($names as $name) {
  457.             $this->unregisterNodeType($name);
  458.         }
  459.     }
  461.     /**
  462.      * Provide Traversable interface: redirect to getAllNodeTypes
  463.      *
  464.      * @return Iterator over all node types
  465.      * @throws RepositoryException
  466.      */
  467.     #[\ReturnTypeWillChange]
  468.     public function getIterator(): \Traversable
  469.     {
  470.         return $this->getAllNodeTypes();
  471.     }
  472. }