PHP Factory::get方法代码示例

 /**
  * Executes this query and returns a QueryResult object.
  *
  * @return \PHPCR\Query\QueryInterface a QueryResult object
  * @throws \PHPCR\Query\InvalidQueryException if the query contains an unbound variable.
  * @throws \PHPCR\RepositoryException if an error occurs
  * @api
  */
 public function execute()
 {
     $transport = $this->objectmanager->getTransport();
     $rawData = $transport->querySQL($this->statement, $this->limit, $this->offset);
     $queryResult = $this->factory->get('Query\\QueryResult', array($rawData, $this->objectmanager));
     return $queryResult;
 }

 /** creates the corresponding workspace */
 public function __construct($factory, Repository $repository, $workspaceName, \PHPCR\SimpleCredentials $credentials, TransportInterface $transport)
 {
     $this->factory = $factory;
     $this->repository = $repository;
     $this->objectManager = $this->factory->get('ObjectManager', array($transport, $this));
     $this->workspace = $this->factory->get('Workspace', array($this, $this->objectManager, $workspaceName));
     $this->credentials = $credentials;
 }

 /**
  * Creates a new query by specifying the query statement itself and the language
  * in which the query is stated. The $language must be a string from among
  * those returned by QueryManager.getSupportedQueryLanguages().
  *
  * @param string $statement
  * @param string $language
  * @return \PHPCR\Query\QueryInterface a Query object
  * @throws \PHPCR\Query\InvalidQueryException if the query statement is syntactically invalid or the specified language is not supported
  * @throws \PHPCR\RepositoryException if another error occurs
  * @api
  */
 public function createQuery($statement, $language)
 {
     switch ($language) {
         case \PHPCR\Query\QueryInterface::JCR_SQL2:
             return $this->factory->get('Query\\SqlQuery', array($statement, $this->objectmanager));
         case \PHPCR\Query\QueryInterface::JCR_JQOM:
             throw new NotImplementedException();
         default:
             throw new \PHPCR\Query\InvalidQueryException("No such query language: {$language}");
     }
 }

 /**
  * Authenticates the user using the supplied credentials. If workspaceName is recognized as the
  * name of an existing workspace in the repository and authorization to access that workspace
  * is granted, then a new Session object is returned. workspaceName is a single string token.
  *
  * null credentials are currently not supported
  *
  * If workspaceName is null, a default workspace is automatically selected by the repository
  * implementation. This may, for example, be the "home workspace" of the user whose credentials
  * were passed, though this is entirely up to the configuration and implementation of the
  * repository. Alternatively, it may be a "null workspace" that serves only to provide the
  * method Workspace.getAccessibleWorkspaceNames(), allowing the client to select from among
  * available "real" workspaces.
  *
  * Note: The Java API defines this method with multiple differing signatures.
  *
  * @param \PHPCR\CredentialsInterface $credentials The credentials of the user
  * @param string $workspaceName the name of a workspace
  * @return \PHPCR\SessionInterface a valid session for the user to access the repository
  * @throws \PHPCR\LoginException if authentication or authorization (for the specified workspace) fails
  * @throws \PHPCR\NoSuchWorkspacexception if the specified workspaceName is not recognized
  * @throws \PHPCR\RepositoryException if another error occurs
  * @api
  */
 public function login($credentials = null, $workspaceName = null)
 {
     if ($workspaceName == null) {
         $workspaceName = 'default';
     }
     //TODO: can default workspace have other name?
     if (!$this->transport->login($credentials, $workspaceName)) {
         throw new \PHPCR\RepositoryException('transport failed to login without telling why');
     }
     $session = $this->factory->get('Session', array($this, $workspaceName, $credentials, $this->transport));
     return $session;
 }

 /**
  * Initializes the created object.
  *
  * @param object $factory  an object factory implementing "get" as described in \jackalope\Factory
  * @param TransportInterface $transport
  */
 public function __construct($factory, TransportInterface $transport)
 {
     $this->factory = $factory;
     $this->transport = $transport;
     $this->namespaceManager = $this->factory->get('NamespaceManager', array($this->defaultNamespaces));
     $namespaces = $transport->getNamespaces();
     foreach ($namespaces as $prefix => $uri) {
         if (!array_key_exists($prefix, $this->defaultNamespaces)) {
             $this->userNamespaces[$prefix] = $uri;
         }
     }
 }

 /**
  * Reads properties from XML
  * @param   DOMElement  $node   The dom to parse properties from
  */
 protected function fromXml(DOMElement $node)
 {
     $this->name = $node->getAttribute('name');
     $this->isAbstract = Helper::getBoolAttribute($node, 'isAbstract');
     $this->isMixin = Helper::getBoolAttribute($node, 'isMixin');
     $this->isQueryable = Helper::getBoolAttribute($node, 'isQueryable');
     $this->hasOrderableChildNodes = Helper::getBoolAttribute($node, 'hasOrderableChildNodes');
     $this->primaryItemName = $node->getAttribute('primaryItemName');
     if (empty($this->primaryItemName)) {
         $this->primaryItemName = null;
     }
     $this->declaredSuperTypeNames = array();
     $xp = new DOMXPath($node->ownerDocument);
     $supertypes = $xp->query('supertypes/supertype', $node);
     foreach ($supertypes as $supertype) {
         $this->declaredSuperTypeNames[] = $supertype->nodeValue;
     }
     $this->declaredPropertyDefinitions = new ArrayObject();
     $properties = $xp->query('propertyDefinition', $node);
     foreach ($properties as $property) {
         $this->declaredPropertyDefinitions[] = $this->factory->get('NodeType\\PropertyDefinition', array($property, $this->nodeTypeManager));
     }
     $this->declaredNodeDefinitions = new ArrayObject();
     $declaredNodeDefinitions = $xp->query('childNodeDefinition', $node);
     foreach ($declaredNodeDefinitions as $nodeDefinition) {
         $this->declaredNodeDefinitions[] = $this->factory->get('NodeType\\NodeDefinition', array($nodeDefinition, $this->nodeTypeManager));
     }
 }

 /**
  * Get the node identified by an absolute path.
  *
  * To prevent unnecessary work to be done a register will be written containing already retrieved nodes.
  * Unfortunately there is currently no way to refetch a node once it has been fetched.
  *
  * @param string $absPath The absolute path of the node to create.
  * @param string $class The class of node to get. TODO: Is it sane to fetch data separatly for Version and normal Node?
  * @return \PHPCR\Node
  *
  * @throws \PHPCR\ItemNotFoundException If nothing is found at that absolute path
  * @throws \PHPCR\RepositoryException    If the path is not absolute or not well-formed
  */
 public function getNodeByPath($absPath, $class = 'Node')
 {
     $absPath = $this->normalizePath($absPath);
     $this->verifyAbsolutePath($absPath);
     if (!isset($this->objectsByPath[$class])) {
         $this->objectsByPath[$class] = array();
     }
     if (empty($this->objectsByPath[$class][$absPath])) {
         if (isset($this->itemsRemove[$absPath])) {
             throw new \PHPCR\ItemNotFoundException('Path not found (node deleted in current session): ' . $absPath);
         }
         // check whether a parent node was removed
         foreach ($this->itemsRemove as $path => $dummy) {
             if (strpos($absPath, $path) === 0) {
                 throw new \PHPCR\ItemNotFoundException('Path not found (parent node deleted in current session): ' . $absPath);
             }
         }
         $fetchPath = $absPath;
         if (isset($this->nodesMove[$absPath])) {
             throw new \PHPCR\ItemNotFoundException('Path not found (moved in current session): ' . $absPath);
         }
         // The path was the destination of a previous move which isn't yet dispatched to the backend.
         // I guess an exception would be fine but we can also just fetch the node from the previous path
         $fetchPath = $this->resolveBackendPath($fetchPath);
         $node = $this->factory->get($class, array($this->transport->getItem($fetchPath), $absPath, $this->session, $this));
         $this->objectsByUuid[$node->getIdentifier()] = $absPath;
         //FIXME: what about nodes that are NOT referencable?
         $this->objectsByPath[$class][$absPath] = $node;
     }
     return $this->objectsByPath[$class][$absPath];
 }

 /**
  * Creates a NodeType from a NodeTypeDefinition and validates it
  *
  * @param   \PHPCR\NodeType\NodeTypeDefinitionInterface  $ntd    The node type definition
  * @param   bool    $allowUpdate    Whether an existing note type can be updated
  * @return \PHPCR\NodeType\NodeType the node type corresponding to the type definition
  * @throws \PHPCR\NodeType\NodeTypeExistsException   If the node type is already existing and allowUpdate is false
  */
 protected function createNodeType(\PHPCR\NodeType\NodeTypeDefinitionInterface $ntd, $allowUpdate)
 {
     if ($this->hasNodeType($ntd->getName()) && !$allowUpdate) {
         throw new \PHPCR\NodeType\NodeTypeExistsException('NodeType already existing: ' . $ntd->getName());
     }
     return $this->factory->get('NodeType\\NodeType', array($this, $ntd));
 }

 /**
  * {@inheritDoc}
  *
  * @api
  */
 public function execute()
 {
     if (is_null($this->objectManager)) {
         // if the ObjectManager was not injected in the header. this is only supposed to happen in the DBAL client.
         throw new RepositoryException('Jackalope implementation error: This query was built for parsing only. (There is no ObjectManager to run the query against.)');
     }
     $transport = $this->objectManager->getTransport();
     $rawData = $transport->query($this);
     $queryResult = $this->factory->get('Query\\QueryResult', array($rawData, $this->objectManager));
     return $queryResult;
 }

 /**
  *getPermissionLevel
  *
  *Get our permission level for this object.
  * ------------------------------------------------------
  * 
  *@throws an exception if permissions were not loaded in an appropriate way for this object.
  *@param user - If a user is passed, we'll load permissions if we don't already have them.
  *
  *@return string
  *
  *
  *
  */
 public function getPermissionLevel($user = false)
 {
     if (!empty($this->_permissions)) {
         return $this->_permissions;
     }
     if (!is_object($user)) {
         throw new \Zend\Db\Exception\InvalidArgumentException('getPermissionLevel called when permissions have not been loaded yet.');
     }
     // Let's try to load permissions for this object.
     return $this->_permissions = Factory::get('ResourcesAccess')->hasResourceAccessTo($user, $this);
 }

 /**
  * Opens a cURL session if not yet one open.
  *
  * @return null|false False in case there is already an open connection, else null;
  */
 protected function getRequest($method, $uri)
 {
     // init curl
     if (is_null($this->curl)) {
         $this->curl = new curl();
     }
     $uri = $this->normalizeUri($uri);
     $request = $this->factory->get('Transport\\Davex\\Request', array($this->curl, $method, $uri));
     $request->setCredentials($this->credentials);
     foreach ($this->defaultHeaders as $header) {
         $request->addHeader($header);
     }
     if (!$this->sendExpect) {
         $request->addHeader("Expect:");
     }
     return $request;
 }

 /** Get instance of some class.
  *
  * This method is will call the Factory object to get a new object of
  * some class. You can specify, if you want to force the creation of a new
  * object or if it is ok for you, to reuse an existing one (default)
  *
  * @param string $class
  *	Class of requested object
  * @param array $values
  *	Parameters to hand to the objects constructor
  * @param bool $forceNew
  *	Force object to be a new one
  *
  * @return object
  */
 public function get($class, $values = array(), $forceNew = false)
 {
     return $this->Factory->get($class, $values, $forceNew);
 }

 public function testGetPrivate()
 {
     $this->assertInstanceOf(self::$classMap['private'], $this->factory->get('unknown'));
 }

 /**
  * Returns the VersionManager object.
  *
  * @return \PHPCR\Version\VersionManagerInterface a VersionManager object.
  * @throws \PHPCR\UnsupportedRepositoryOperationException if the implementation does not support versioning.
  * @throws \PHPCR\RepositoryException if an error occurs.
  * @api
  */
 public function getVersionManager()
 {
     return $this->factory->get('Version\\VersionManager', array($this->session->getObjectManager()));
 }

 /**
  * @param string $daoName
  * @return Dao
  */
 public function get($daoName)
 {
     return parent::get($daoName);
 }