vendor/jackalope/jackalope/src/Jackalope/NodeType/NodeTypeDefinition.php line 163

  1. <?php
  3. namespace Jackalope\NodeType;
  5. use DOMElement;
  6. use ArrayObject;
  7. use InvalidArgumentException;
  8. use PHPCR\NodeType\NodeTypeDefinitionInterface;
  9. use Jackalope\FactoryInterface;
  10. use PHPCR\Util\ValueConverter;
  12. /**
  13.  * {@inheritDoc}
  14.  *
  15.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  16.  * @license http://opensource.org/licenses/MIT MIT License
  17.  *
  18.  * @api
  19.  */
  20. class NodeTypeDefinition implements NodeTypeDefinitionInterface
  21. {
  22.     const NAME_NT_BASE = 'nt:base';
  24.     /**
  25.      * The factory to instantiate objects
  26.      * @var FactoryInterface
  27.      */
  28.     protected $factory;
  30.     /**
  31.      * @var NodeTypeManager
  32.      */
  33.     protected $nodeTypeManager;
  35.     /**
  36.      * @var ValueConverter
  37.      */
  38.     protected $valueConverter;
  40.     /**
  41.      * The name of this node type definition.
  42.      * @var string
  43.      */
  44.     protected $name = null;
  46.     /**
  47.      * @var boolean
  48.      */
  49.     protected $isAbstract = false;
  51.     /**
  52.      * Whether this is a mixin node type (otherwise it's a primary node type).
  53.      * @var boolean
  54.      */
  55.     protected $isMixin = false;
  57.     /**
  58.      * @var boolean
  59.      */
  60.     protected $isQueryable = true;
  62.     /**
  63.      * @var boolean
  64.      */
  65.     protected $hasOrderableChildNodes = false;
  67.     /**
  68.      * Name of the primary item of this node type.
  69.      * @var string
  70.      */
  71.     protected $primaryItemName = null;
  73.     /**
  74.      * @var array
  75.      */
  76.     protected $declaredSuperTypeNames = null;
  78.     /**
  79.      * @var ArrayObject
  80.      */
  81.     protected $declaredPropertyDefinitions = null;
  83.     /**
  84.      * @var ArrayObject
  85.      */
  86.     protected $declaredNodeDefinitions = null;
  88.     /**
  89.      * Create a new node type definition.
  90.      *
  91.      * Optionally initializes the data from XML, an array or another
  92.      * NodeTypeDefinition.
  93.      *
  94.      * @param FactoryInterface $factory         the object factory
  95.      * @param NodeTypeManager  $nodeTypeManager
  96.      * @param DOMElement|NodeTypeDefinitionInterface|null
  97.      *      $nodetype Either by XML or by NodeTypeDefinition or null for an
  98.      *      empty definition
  99.      *
  100.      * @throws InvalidArgumentException If it is not possible to read data
  101.      *      from $nodetype
  102.      */
  103.     public function __construct(FactoryInterface $factory, NodeTypeManager $nodeTypeManager, $nodetype = null)
  104.     {
  105.         $this->factory = $factory;
  106.         $this->valueConverter = $this->factory->get(ValueConverter::class);
  107.         $this->nodeTypeManager = $nodeTypeManager;
  109.         if ($nodetype instanceof DOMElement) {
  110.             $this->fromXml($nodetype);
  111.         } elseif (is_array($nodetype)) {
  112.             $this->fromArray($nodetype);
  113.         } elseif ($nodetype instanceof NodeTypeDefinitionInterface) {
  114.             $this->fromNodeTypeDefinition($nodetype); // copy constructor
  115.         } elseif (!is_null($nodetype)) {
  116.             throw new InvalidArgumentException('Implementation Error -- unknown nodetype class: '.get_class($nodetype));
  117.         }
  118.     }
  120.     /**
  121.      * Read the node type definition from another NodeTypeDefinition
  122.      *
  123.      * @param NodeTypeDefinitionInterface $ntd The node type
  124.      *      definition to copy information from
  125.      */
  126.     protected function fromNodeTypeDefinition(NodeTypeDefinitionInterface $ntd)
  127.     {
  128.         $this->name = $ntd->getName();
  129.         $this->isAbstract = $ntd->isAbstract();
  130.         $this->isMixin = $ntd->isMixin();
  131.         $this->isQueryable = $ntd->isQueryable();
  132.         $this->hasOrderableChildNodes = $ntd->hasOrderableChildNodes();
  133.         $this->primaryItemName = $ntd->getPrimaryItemName();
  134.         $this->declaredSuperTypeNames = $ntd->getDeclaredSupertypeNames();
  135.         $this->declaredPropertyDefinitions = new ArrayObject($ntd->getDeclaredPropertyDefinitions() ?: []);
  136.         $this->declaredNodeDefinitions = new ArrayObject($ntd->getDeclaredChildNodeDefinitions() ?: []);
  137.     }
  139.     /**
  140.      * Reads the node type definition from an array
  141.      *
  142.      * @param array $data an array with key-value information
  143.      */
  144.     protected function fromArray(array $data)
  145.     {
  146.         $this->name = $data['name'];
  147.         $this->isAbstract = $data['isAbstract'];
  148.         $this->isMixin = $data['isMixin'];
  149.         $this->isQueryable = $data['isQueryable'];
  150.         $this->hasOrderableChildNodes = $data['hasOrderableChildNodes'];
  151.         $this->primaryItemName = $data['primaryItemName'] ?: null;
  152.         $this->declaredSuperTypeNames = (isset($data['declaredSuperTypeNames']) && count($data['declaredSuperTypeNames'])) ? $data['declaredSuperTypeNames'] : [];
  153.         $this->declaredPropertyDefinitions = new ArrayObject();
  155.         foreach ($data['declaredPropertyDefinitions'] as $propertyDef) {
  156.             $this->declaredPropertyDefinitions[] = $this->factory->get(
  157.                 PropertyDefinition::class,
  158.                 [$propertyDef, $this->nodeTypeManager]
  159.             );
  160.         }
  161.         $this->declaredNodeDefinitions = new ArrayObject();
  162.         foreach ($data['declaredNodeDefinitions'] as $nodeDef) {
  163.             $this->declaredNodeDefinitions[] = $this->factory->get(
  164.                 NodeDefinition::class,
  165.                 [$nodeDef, $this->nodeTypeManager]
  166.             );
  167.         }
  168.     }
  170.     /**
  171.      * Reads the node type definition from an xml element
  172.      *
  173.      * @param DOMElement $node The dom element to read information from
  174.      */
  175.     protected function fromXml(DOMElement $node)
  176.     {
  177.         $nodeTypeXmlConverter = new NodeTypeXmlConverter($this->factory);
  178.         $this->fromArray($nodeTypeXmlConverter->getNodeTypeDefinitionFromXml($node));
  179.     }
  181.     /**
  182.      * {@inheritDoc}
  183.      *
  184.      * @api
  185.      */
  186.     public function getName()
  187.     {
  188.         return $this->name;
  189.     }
  191.     /**
  192.      * {@inheritDoc}
  193.      *
  194.      * @api
  195.      */
  196.     public function getDeclaredSupertypeNames()
  197.     {
  198.         if (null === $this->declaredSuperTypeNames) {
  199.             return [self::NAME_NT_BASE];
  200.         }
  202.         return $this->declaredSuperTypeNames;
  203.     }
  205.     /**
  206.      * {@inheritDoc}
  207.      *
  208.      * @api
  209.      */
  210.     public function isAbstract()
  211.     {
  212.         return $this->isAbstract;
  213.     }
  215.     /**
  216.      * {@inheritDoc}
  217.      *
  218.      * @api
  219.      */
  220.     public function isMixin()
  221.     {
  222.         return $this->isMixin;
  223.     }
  225.     /**
  226.      * {@inheritDoc}
  227.      *
  228.      * @api
  229.      */
  230.     public function hasOrderableChildNodes()
  231.     {
  232.         return $this->hasOrderableChildNodes;
  233.     }
  235.     /**
  236.      * {@inheritDoc}
  237.      *
  238.      * @api
  239.      */
  240.     public function isQueryable()
  241.     {
  242.         return $this->isQueryable;
  243.     }
  245.     /**
  246.      * {@inheritDoc}
  247.      *
  248.      * @api
  249.      */
  250.     public function getPrimaryItemName()
  251.     {
  252.         return $this->primaryItemName;
  253.     }
  255.     /**
  256.      * {@inheritDoc}
  257.      *
  258.      * @api
  259.      */
  260.     public function getDeclaredPropertyDefinitions()
  261.     {
  262.         return null === $this->declaredPropertyDefinitions
  263.             ? null : $this->declaredPropertyDefinitions->getArrayCopy();
  264.     }
  266.     /**
  267.      * {@inheritDoc}
  268.      *
  269.      * @api
  270.      */
  271.     public function getDeclaredChildNodeDefinitions()
  272.     {
  273.         return null === $this->declaredNodeDefinitions
  274.             ? null : $this->declaredNodeDefinitions->getArrayCopy();
  275.     }
  276. }