Пример #1
0
 /**
  * Tries to identify the class of an rid by matching it against
  * the clusters in the database
  *
  * @param string $rid
  *
  * @throws MappingException
  * @return string
  */
 public function identifyClass($rid)
 {
     $map = $this->getMap();
     $splitRid = explode(':', ltrim($rid, '#'));
     $clusterId = $splitRid[0];
     foreach ($map as $class => $clusters) {
         if (in_array($clusterId, $clusters)) {
             return $class;
         }
     }
     throw MappingException::noClusterForRid($rid);
 }
 /**
  * Lookup the document class to find methods that match to event lifecycle names
  *
  * @param ClassMetadata $metadata  The document metadata.
  * @param string        $className The listener class name.
  *
  * @throws MappingException           When the listener class not found.
  */
 public static function bindDocumentListener(ClassMetadata $metadata, $className)
 {
     $class = $metadata->fullyQualifiedClassName($className);
     if (!class_exists($class)) {
         throw MappingException::documentListenerClassNotFound($class, $className);
     }
     foreach (get_class_methods($class) as $method) {
         if (!isset(self::$events[$method])) {
             continue;
         }
         $metadata->addDocumentListener($method, $class, $method);
     }
 }
Пример #3
0
 /**
  * Overrides an already defined type to use a different implementation.
  *
  * @static
  *
  * @param string $name
  * @param string $className
  *
  * @throws MappingException
  */
 public static final function overrideType($name, $className)
 {
     if (!isset(self::$typesMap[$name])) {
         throw MappingException::typeNotFound($name);
     }
     self::$typesMap[$name] = $className;
 }
Пример #4
0
 /**
  * @param string            $className
  * @param ClassMetadata     $metadata
  * @param DocumentListeners $annot
  *
  * @throws MappingException
  */
 private function mapDocumentListeners($className, ClassMetadata $metadata, DocumentListeners $annot)
 {
     foreach ($annot->value as $item) {
         $listenerClassName = $metadata->fullyQualifiedClassName($item);
         if (!class_exists($listenerClassName)) {
             throw MappingException::documentListenerClassNotFound($listenerClassName, $className);
         }
         $hasMapping = false;
         $listenerClass = new \ReflectionClass($listenerClassName);
         /* @var $method \ReflectionMethod */
         foreach ($listenerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
             // find method callbacks.
             $callbacks = $this->getMethodCallbacks($method);
             $hasMapping = $hasMapping ?: !empty($callbacks);
             foreach ($callbacks as $value) {
                 $metadata->addDocumentListener($value[1], $listenerClassName, $value[0]);
             }
         }
         // Evaluate the listener using naming convention.
         if (!$hasMapping) {
             DocumentListenerBuilder::bindDocumentListener($metadata, $listenerClassName);
         }
     }
 }
Пример #5
0
 /**
  * @param array $mapping
  *
  * @throws MappingException
  */
 private function _validateFieldMapping(array &$mapping)
 {
     if (!isset($mapping['fieldName'])) {
         throw MappingException::missingFieldName($this->name);
     }
     if (isset($this->fieldMappings[$mapping['fieldName']])) {
         throw MappingException::duplicateFieldMapping($this->name, $mapping['fieldName']);
     }
 }
 /**
  * Validate runtime metadata is correctly defined.
  *
  * @param ClassMetadata      $class
  * @param ClassMetadata|null $parent
  *
  * @return void
  *
  * @throws MappingException
  */
 protected function validateRuntimeMetadata($class, $parent)
 {
     $className = $class->getName();
     if ($this->isEntity($class) && empty($class->identifier)) {
         throw MappingException::missingRidProperty($className);
     }
     if ($class->isDocument() && !isset($class->orientClass)) {
         throw MappingException::missingOClass($className);
     }
 }
Пример #7
0
 private function addLinkMapping(ClassMetadata $class, \SimpleXMLElement $embed, $type)
 {
     $attributes = $embed->attributes();
     $mapping = ['cascade' => isset($embed->cascade) ? $this->_getCascadeMappings($embed->cascade) : []];
     $this->_copyCommonPropertyAttributesToMapping($attributes, $mapping);
     if (isset($attributes['orphan-removal'])) {
         $mapping['orphanRemoval'] = (string) $attributes['orphan-removal'] === 'true';
     }
     if (isset($attributes['parent-property'])) {
         $mapping['parentProperty'] = (string) $attributes['parent-property'];
     }
     if (isset($attributes['child-property'])) {
         $mapping['childProperty'] = (string) $attributes['child-property'];
     }
     switch ($type) {
         case 'one':
             $class->mapLink($mapping);
             break;
         case 'list':
             $class->mapLinkList($mapping);
             break;
         case 'set':
             $class->mapLinkSet($mapping);
             break;
         case 'map':
             $class->mapLinkMap($mapping);
             break;
         default:
             throw MappingException::invalidCollectionType($class->name, $type);
     }
 }