PHP Code::castGetter方法代码示例

 public function validate($data)
 {
     if (empty($data)) {
         $e = new EmptyDataException();
         $e->setDefaultValue(array());
         throw $e;
     }
     $data = json_decode($data, true);
     if (count($data) == 0) {
         $e = new EmptyDataException();
         $e->setDefaultValue(array());
         throw $e;
     }
     $rep = $this->em->getRepository($this->entityName);
     $collection = $rep->findAllByIds($data, $this->idName);
     // überspringt dies fehlende Ids?
     // sortieren nach der Data List (da findAllByIds das nicht tut, und das ist auch gut so)
     $getter = \Psc\Code\Code::castGetter($this->idName);
     $keys = array_flip($data);
     usort($collection, function ($entityA, $entityB) use($keys, $getter) {
         $keyA = $keys[$getter($entityA)];
         $keyB = $keys[$getter($entityB)];
         if ($keyA === $keyB) {
             return 0;
         }
         return $keyA > $keyB ? 1 : -1;
     });
     if (count($collection) == count($data)) {
         return $collection;
     } else {
         throw new \Psc\Exception('Unexpected: Es wurden: ' . count($collection) . ' IDs hydriert, aber ' . count($data) . ' IDs angegeben.');
     }
 }

 /**
  * @var mixed $print Closure|String wenn ein String wird dies als Attribute gesehen welches mit get$print() vom Objekt geladen werden kann
  */
 public static function listObjects($objectCollection, $sep = ', ', $print = 'Id', $andsep = NULL, Closure $formatter = NULL)
 {
     $objectCollection = Code::castArray($objectCollection);
     $cnt = count($objectCollection);
     if (isset($andsep) && $cnt > 1) {
         $last = array_pop($objectCollection);
     } else {
         $andsep = NULL;
     }
     if (is_string($print) || $print instanceof Closure) {
         $g = Code::castGetter($print);
     } else {
         throw new \InvalidArgumentException('Unbekannter Parameter für $print: ' . Code::varInfo($print));
     }
     $formatter = $formatter ?: function ($item) {
         return (string) $item;
     };
     $ret = A::implode($objectCollection, $sep, function ($object, $key) use($g, $formatter) {
         // formatiere das $print-Attribute von $object
         return $formatter($g($object, $key), $key);
     });
     if (isset($andsep) && $last != NULL) {
         $ret .= $andsep . $formatter($g($last));
     }
     return $ret;
 }

 protected function generateGetter($property)
 {
     return Code::castGetter($property);
 }

 public function sortComponentsBy($property)
 {
     Code::value($property, 'formName', 'formValue', 'formLabel', 'componentName');
     $getter = Code::castGetter($property);
     $sorting = function ($c1, $c2) use($getter) {
         return strcmp($getter($c1), $getter($c2));
     };
     $this->sortComponents($sorting);
     return $this;
 }

 /**
  * Fügt die beiden Collections Ahand der Funktion $getIndex zusammen
  *
  * der Array hat als schlüssel die werte von jedem objekt der collection auf das $getIndex angewandt wurde
  * jedes Element kommt nur einmal vor.
  *
  * @see Code::castGetter()
  */
 public static function mergeUnique(array $collection1, array $collection2, $getIndex1, $getIndex2 = NULL)
 {
     $getIndex1 = Code::castGetter($getIndex1);
     if (!isset($getIndex2)) {
         $getIndex2 = $getIndex1;
     } else {
         $getIndex2 = Code::castGetter($getIndex2);
     }
     $merge = array();
     foreach ($collection1 as $o) {
         $merge[$getIndex1($o)] = $o;
     }
     foreach ($collection2 as $o) {
         $index = $getIndex2($o);
         if (!array_key_exists($index, $merge)) {
             $merge[$index] = $o;
         }
     }
     return $merge;
 }

 /**
  * 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)
         }
     }
//.........这里部分代码省略.........

 public function testCastGetter()
 {
     $object = new TestingClass('v1', 'v2');
     // pre
     $this->assertEquals('v1', $object->getProp1());
     $this->assertEquals('v2', $object->getProp2());
     // test
     $getter = Code::castGetter('prop1');
     $this->assertEquals('v1', $getter($object));
     $getter = Code::castGetter('prop2');
     $this->assertEquals('v2', $getter($object));
     // test mit get
     $getter = Code::castGetter('getProp1');
     $this->assertEquals('v1', $getter($object));
     $getter = Code::castGetter('getProp2');
     $this->assertEquals('v2', $getter($object));
 }