vendor/jackalope/jackalope/src/Jackalope/Workspace.php line 87

  1. <?php
  2. namespace Jackalope;
  4. use Jackalope\Lock\LockManager;
  5. use Jackalope\Observation\ObservationManager;
  6. use Jackalope\Query\QueryManager;
  7. use Jackalope\Version\VersionManager;
  8. use PHPCR\Lock\LockManagerInterface;
  9. use PHPCR\Observation\ObservationManagerInterface;
  10. use PHPCR\WorkspaceInterface;
  11. use PHPCR\UnsupportedRepositoryOperationException;
  12. use PHPCR\Transaction\UserTransactionInterface;
  13. use Jackalope\NodeType\NodeTypeManager;
  14. use Jackalope\ImportExport\ImportExport;
  15. use Jackalope\Transport\QueryInterface;
  16. use Jackalope\Transport\WritingInterface;
  17. use Jackalope\Transport\WorkspaceManagementInterface;
  18. use Jackalope\Transport\VersioningInterface;
  19. use Jackalope\Transport\TransactionInterface;
  20. use Jackalope\Transport\LockingInterface;
  21. use Jackalope\Transport\ObservationInterface;
  23. /**
  24.  * {@inheritDoc}
  25.  *
  26.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  27.  * @license http://opensource.org/licenses/MIT MIT License
  28.  *
  29.  * @api
  30.  */
  31. class Workspace implements WorkspaceInterface
  32. {
  33.     /**
  34.      * The factory to instantiate objects
  35.      *
  36.      * @var FactoryInterface
  37.      */
  38.     protected $factory;
  40.     /**
  41.      * @var Session
  42.      */
  43.     protected $session;
  45.     /**
  46.      * @var NodeTypeManager
  47.      */
  48.     protected $nodeTypeManager;
  50.     /**
  51.      * @var UserTransactionInterface
  52.      */
  53.     protected $userTransactionManager = null;
  55.     /**
  56.      * The name of the workspace this workspace represents
  57.      *
  58.      * @var string
  59.      */
  60.     protected $name;
  62.     /**
  63.      * The namespace registry.
  64.      *
  65.      * @var NamespaceRegistry
  66.      */
  67.     protected $namespaceRegistry;
  69.     /**
  70.      * @var LockManagerInterface
  71.      */
  72.     protected $lockManager;
  74.     /**
  75.      * @var ObservationManagerInterface
  76.      */
  77.     protected $observationManager;
  79.     /**
  80.      * Instantiate a workspace referencing a workspace in the storage.
  81.      *
  82.      * @param FactoryInterface $factory       the object factory
  83.      * @param Session          $session
  84.      * @param ObjectManager    $objectManager
  85.      * @param string           $name          the workspace name that is used
  86.      */
  87.     public function __construct(FactoryInterface $factory, Session $session, ObjectManager $objectManager, $name)
  88.     {
  89.         $this->factory = $factory;
  90.         $this->session = $session;
  91.         $this->nodeTypeManager = $this->factory->get(NodeTypeManager::class, [$objectManager, $this->getNamespaceRegistry()]);
  92.         $this->name = $name;
  93.     }
  95.     /**
  96.      * {@inheritDoc}
  97.      *
  98.      * @api
  99.      */
  100.     public function getSession()
  101.     {
  102.         return $this->session;
  103.     }
  105.     /**
  106.      * {@inheritDoc}
  107.      *
  108.      * @api
  109.      */
  110.     public function getName()
  111.     {
  112.         return $this->name;
  113.     }
  115.     /**
  116.      * {@inheritDoc}
  117.      *
  118.      * @api
  119.      */
  120.     public function copy($srcAbsPath, $destAbsPath, $srcWorkspace = null)
  121.     {
  122.         $this->session->getObjectManager()->copyNodeImmediately($srcAbsPath, $destAbsPath, $srcWorkspace);
  123.     }
  125.     /**
  126.      * {@inheritDoc}
  127.      *
  128.      * @api
  129.      */
  130.     public function cloneFrom($srcWorkspace, $srcAbsPath, $destAbsPath, $removeExisting)
  131.     {
  132.         if (! $this->session->getObjectManager()->getTransport() instanceof WritingInterface) {
  133.             throw new UnsupportedRepositoryOperationException('Transport does not support writing');
  134.         }
  136.         $this->session
  137.             ->getObjectManager()
  138.             ->cloneFromImmediately($srcWorkspace, $srcAbsPath, $destAbsPath, $removeExisting);
  139.     }
  141.     /**
  142.      * {@inheritDoc}
  143.      *
  144.      * @api
  145.      */
  146.     public function move($srcAbsPath, $destAbsPath)
  147.     {
  148.         $this->session->getObjectManager()->moveNodeImmediately($srcAbsPath, $destAbsPath);
  149.     }
  151.     /**
  152.      * {@inheritDoc}
  153.      *
  154.      * @api
  155.      */
  156.     public function removeItem($absPath)
  157.     {
  158.         $this->session->getObjectManager()->removeItemImmediately($absPath);
  159.     }
  161.     /**
  162.      * {@inheritDoc}
  163.      *
  164.      * @api
  165.      */
  166.     public function getLockManager()
  167.     {
  168.         if (! $this->session->getTransport() instanceof LockingInterface) {
  169.             throw new UnsupportedRepositoryOperationException('Transport does not support locking');
  170.         }
  172.         if (null === $this->lockManager) {
  173.             $this->lockManager = $this->factory->get(
  174.                 LockManager::class,
  175.                 [
  176.                     $this->session->getObjectManager(),
  177.                     $this->session,
  178.                     $this->session->getTransport()
  179.                 ]
  180.             );
  181.         }
  183.         return $this->lockManager;
  184.     }
  186.     /**
  187.      * {@inheritDoc}
  188.      *
  189.      * @api
  190.      */
  191.     public function getQueryManager()
  192.     {
  193.         if (! $this->session->getTransport() instanceof QueryInterface) {
  194.             throw new UnsupportedRepositoryOperationException('Transport does not support queries');
  195.         }
  197.         return $this->factory->get(QueryManager::class, [$this->session->getObjectManager()]);
  198.     }
  200.     /**
  201.      * Sets the TransactionManager
  202.      *
  203.      * Called by the repository if transactions are enabled. Transactions are
  204.      * enabled if this is called with a non-null argument, disabled otherwise.
  205.      *
  206.      * @param UserTransactionInterface $userTransactionManager A UserTransaction object
  207.      *
  208.      * @private
  209.      */
  210.     public function setTransactionManager(UserTransactionInterface $userTransactionManager)
  211.     {
  212.         if (! $this->session->getTransport() instanceof TransactionInterface) {
  213.             throw new UnsupportedRepositoryOperationException('Transport does not support transactions');
  214.         }
  216.         $this->userTransactionManager = $userTransactionManager;
  217.     }
  219.     /**
  220.      * {@inheritDoc}
  221.      *
  222.      * @api
  223.      */
  224.     public function getTransactionManager()
  225.     {
  226.         if (! $this->session->getTransport() instanceof TransactionInterface) {
  227.             throw new UnsupportedRepositoryOperationException('Transport does not support transactions');
  228.         }
  230.         if (! $this->userTransactionManager) {
  231.             throw new UnsupportedRepositoryOperationException('Transactions are currently disabled');
  232.         }
  234.         return $this->userTransactionManager;
  235.     }
  237.     /**
  238.      * {@inheritDoc}
  239.      *
  240.      * @api
  241.      */
  242.     public function getNamespaceRegistry()
  243.     {
  244.         if ($this->namespaceRegistry === null) {
  245.             $this->namespaceRegistry = $this->factory->get(NamespaceRegistry::class, [$this->session->getTransport()]);
  246.         }
  248.         return $this->namespaceRegistry;
  249.     }
  251.     /**
  252.      * {@inheritDoc}
  253.      *
  254.      * @api
  255.      */
  256.     public function getNodeTypeManager()
  257.     {
  258.         return $this->nodeTypeManager;
  259.     }
  261.     /**
  262.      * {@inheritDoc}
  263.      *
  264.      * @api
  265.      */
  266.     public function getObservationManager()
  267.     {
  268.         if (! $this->session->getTransport() instanceof ObservationInterface) {
  269.             throw new UnsupportedRepositoryOperationException('Transport does not support observation');
  270.         }
  272.         if (is_null($this->observationManager)) {
  273.             $this->observationManager = $this->factory->get(
  274.                 ObservationManager::class,
  275.                 [
  276.                     $this->session,
  277.                     $this->session->getTransport()
  278.                 ]
  279.             );
  280.         }
  282.         return $this->observationManager;
  283.     }
  285.     /**
  286.      * {@inheritDoc}
  287.      *
  288.      * @api
  289.      */
  290.     public function getRepositoryManager()
  291.     {
  292.         throw new UnsupportedRepositoryOperationException();
  293.     }
  295.     /**
  296.      * {@inheritDoc}
  297.      *
  298.      * @api
  299.      */
  300.     public function getVersionManager()
  301.     {
  302.         if (! $this->session->getTransport() instanceof VersioningInterface) {
  303.             throw new UnsupportedRepositoryOperationException('Transport does not support versioning');
  304.         }
  306.         return $this->factory->get(VersionManager::class, [$this->session->getObjectManager()]);
  307.     }
  309.     /**
  310.      * {@inheritDoc}
  311.      *
  312.      * @api
  313.      */
  314.     public function getAccessibleWorkspaceNames()
  315.     {
  316.         return $this->session->getTransport()->getAccessibleWorkspaceNames();
  317.     }
  319.     /**
  320.      * {@inheritDoc}
  321.      *
  322.      * @api
  323.      */
  324.     public function importXML($parentAbsPath, $uri, $uuidBehavior)
  325.     {
  326.         ImportExport::importXML(
  327.             $this->getSession()->getNode($parentAbsPath),
  328.             $this->getNamespaceRegistry(),
  329.             $uri,
  330.             $uuidBehavior
  331.         );
  332.     }
  334.     /**
  335.      * {@inheritDoc}
  336.      *
  337.      * @api
  338.      */
  339.     public function createWorkspace($name, $srcWorkspace = null)
  340.     {
  341.         if (! $this->session->getTransport() instanceof WorkspaceManagementInterface) {
  342.             throw new UnsupportedRepositoryOperationException('Transport does not support workspace management');
  343.         }
  345.         return $this->session->getTransport()->createWorkspace($name, $srcWorkspace);
  346.     }
  348.     /**
  349.      * {@inheritDoc}
  350.      *
  351.      * @api
  352.      */
  353.     public function deleteWorkspace($name)
  354.     {
  355.         if (! $this->session->getTransport() instanceof WorkspaceManagementInterface) {
  356.             throw new UnsupportedRepositoryOperationException('Transport does not support workspace management');
  357.         }
  359.         return $this->session->getTransport()->deleteWorkspace($name);
  360.     }
  361. }