PHP Code::castCollection方法代码示例

 public function process($fromCollection, $toCollection)
 {
     // der genericCollectionSynchronizer braucht ArrayCollections
     $fromCollection = Code::castCollection($fromCollection);
     $toCollection = Code::castCollection($toCollection);
     // die defaults sind: compare nach object, hashe nach identifier, und die sind prima für uns
     $this->innerSynchronizer->process($fromCollection, $toCollection);
 }

 /**
  *
  * @controller-api
  * @TODO orderby?
  */
 public function getEntities(array $query = array(), $subResource = NULL)
 {
     if ($subResource === 'search') {
         return $this->getEntitySearchPanel($this->getEntityMeta(), $query);
     } elseif ($subResource !== NULL && array_key_exists($subResource, $this->customActions)) {
         return $this->callCustomAction($this->customActions[$subResource], array($query));
     }
     if (array_key_exists('autocomplete', $query) && $query['autocomplete'] === 'true') {
         $entityMeta = $this->getEntityMeta();
         $fields = array_keys($entityMeta->getAutoCompleteFields());
         $maxResults = isset($query['maxResults']) ? max(1, (int) $query['maxResults']) : NULL;
         $entities = $this->doAutoCompleteEntities($fields, $query['search'], array_key_exists('filters', $query) ? (array) $query['filters'] : array(), $maxResults);
         $exporter = new \Psc\CMS\Item\Exporter();
         $export = array();
         foreach ($entities as $entity) {
             // @TODO es wäre schön hier spezifizieren zu können welche interfaces exportiert werden müssen
             // dies muss vom request her passieren
             $export[] = $exporter->ComboDropBoxable($entityMeta->getAdapter($entity)->getComboDropBoxable());
             //$export[] = $exporter->AutoCompletable($entityMeta->getAdapter($entity)->getAutoCompletable());
             //$export[] = $exporter->merge($entityMeta->getAdapter($entity),
             //                           array('AutoCompletable','Identifyable','TabOpenable')
             //                           );
         }
         if (isset($maxResults) && count($export) === $maxResults) {
             // exceeds
             $this->metadata = new MetadataGenerator();
             $this->metadata->autoCompleteMaxResultsHit($maxResults);
         }
         return $export;
     } else {
         $entities = $this->findEntitiesFor($query, $this->getDefaultSort(), $subResource);
     }
     if ($subResource === NULL) {
         return Code::castCollection($entities);
     } elseif ($subResource === 'grid') {
         return $this->getEntityGrid($this->dc->getEntityMeta($this->getEntityName()), $entities);
     } else {
         throw $this->err->invalidArgument(__FUNCTION__, 'subResource', $subResource);
     }
 }

 /**
  * Synchronisiert eine Collection eines Entities mit Entities in der Datenbank (deprecated)
  *
  * Diese Art der Synchroniserung ist deprecated, weil es mittlerweile ausgelagerte Funktionen dafür gibt
  * (siehe Psc\Doctrine\*Synchro*)
  * 
  * also es werden für die bestehenden Objekte in $entity->$collectionProperty die objekte gelöscht
  * die nicht in newCollection drin sind und die, die in $newCollection drin sind aber nicht in
  * $entity->$collectionProperty gelöscht
  * 
  * - Achtung(!): dies führt persist() auf den Entitys der Collection (also quasi andere Seite der Association) aus, wenn $this->entity nicht die Owning-Side der CollectionAssociation ist
  * - Dies führt persist für items in newCollection, die neu sind
  * 
  * Die Basis für eine erfolgreiche Synchronization ist eine $newCollection die wirklich die gleichen Objekte enthält, für die Updates gemacht werden sollen. Also vorsicht mit serialisierten Einträgen und clones
  * 
  * @param string $associationName der Name des Properties der Collection in $entity
  */
 public function synchronizeCollection($associationName, $newCollection)
 {
     if (!is_string($associationName)) {
         throw new \Psc\Exception('string erwartet: ' . Code::varInfo($associationName));
     }
     /*
         $mapping     = $coll->getMapping();
         $targetClass = $this->_em->getClassMetadata($mapping['targetEntity']);
         $sourceClass = $this->_em->getClassMetadata($mapping['sourceEntity']);
         $id          = $this->_em->getUnitOfWork()->getEntityIdentifier($coll->getOwner());
     */
     if ($this->entity instanceof \Psc\Doctrine\Object) {
         $entityClass = $this->entity->getDoctrineMetadata();
         // Sound
     } elseif ($this->entity instanceof \Psc\Doctrine\Entity) {
         $entityClass = $this->em->getClassMetadata($this->entity->getEntityName());
     } else {
         throw new \InvalidArgumentException('$this->entity ist von der Klasse: ' . Code::getClass($this->entity) . ' und diese ist unbekannt');
     }
     $entityAssoc = $entityClass->getAssociationMapping($associationName);
     // speakers
     $owning = $entityAssoc['isOwningSide'];
     // true
     $targetClass = $this->em->getClassMetadata($entityAssoc['targetEntity']);
     // Metadata:Speaker
     if ($owning) {
         $entityProperty = $entityAssoc['inversedBy'];
         $collectionProperty = $entityAssoc['fieldName'];
     } else {
         $entityProperty = $entityAssoc['mappedBy'];
         $collectionProperty = $entityAssoc['fieldName'];
     }
     // entityProperty = sounds
     // collectionProperty = speakers
     $getter = Code::castGetter($collectionProperty);
     //getSpeakers
     $collection = $getter($this->entity);
     // $this->entity->getSpeakers()
     $collection = Code::castCollection($collection);
     $newCollection = Code::castCollection($newCollection);
     $this->log(sprintf("synchronizeCollection '%s'", $associationName));
     $this->log('in DBCollection:');
     $this->log(DoctrineHelper::debugCollection($collection));
     $this->log(NULL);
     $this->log('in FormCollection:');
     $this->log(DoctrineHelper::debugCollection($newCollection));
     $this->log(NULL);
     $this->log('Processing:');
     /*
       Wir synchronisieren hier auf der Owning Side oder Reverse Side
       jenachdem müssen wir auf der owning oder reverse side die add + remove funktionen aufrufen
     */
     if ($owning) {
         $remove = 'remove' . ucfirst(Inflector::singular($collectionProperty));
         // removeSpeaker
         $add = 'add' . ucfirst(Inflector::singular($collectionProperty));
         // addSpeaker
     } else {
         $remove = 'remove' . ucfirst(Inflector::singular($entityProperty));
         // removeSound
         $add = 'add' . ucfirst(Inflector::singular($entityProperty));
         // addSound
     }
     $logThis = Code::getClassName($entityClass->getName());
     // @TODO hier mit reflection prüfen
     //if (!->hasMethod($remove)) {
     //  throw new \Psc\Exception('Es gibt keine '.$remove.' Methode im Entity: '.$owningEntity);
     //}
     //if (!$this->entity->hasMethod($add)) {
     //  throw new \Psc\Exception('Es gibt keine '.$add.' Methode im Entity: '.$owningEntity);
     //}
     //
     foreach ($collection->deleteDiff($newCollection, ArrayCollection::COMPARE_OBJECTS) as $entity) {
         if ($owning) {
             $this->entity->{$remove}($entity);
             // $sound->removeSpeaker($speaker)
         } else {
             $this->em->persist($entity);
             // $speaker persist
             $entity->{$remove}($this->entity);
             // $speaker->removeSound($sound)
         }
     }
//.........这里部分代码省略.........

 /**
  * Erstellt einen ComponentsValidator anhand des EntityFormPanels
  *
  * Der FormPanel muss die Componenten schon erstellt haben sie werden mit getComponents() aus dem Formular genommen
  */
 public function createComponentsValidator(FormData $requestData, EntityFormPanel $panel, DCPackage $dc, array $components = NULL)
 {
     $this->validationEntity = $entity = $panel->getEntityForm()->getEntity();
     $components = isset($components) ? Code::castCollection($components) : $panel->getEntityForm()->getComponents();
     return $this->componentsValidator = new ComponentsValidator($this->createFormDataSet($requestData, $panel, $entity), $components, $this->componentRuleMapper);
 }