PHP Code::varInfo方法代码示例

 public function convertToDatabaseValue($value, AbstractPlatform $platform)
 {
     if (!in_array($value, $this->getValues())) {
         throw new \InvalidArgumentException("Invalid '" . $this->name . "' value " . \Psc\Code\Code::varInfo($value) . ' Erlaubt sind: ' . \Psc\Code\Code::varInfo($this->values));
     }
     return $value;
 }

 /**
  * Überprüft die Daten anhand der Constraints und fügt die Daten zum Index hinzu
  *
  * Schmeisst eine Exception wenn die daten bereits im Index sind
  * diese Exception wird mit duplicateIdentifier gesetzt, wenn in $data der key 'identifier' für den vorigen Index-Eintrag gesetzt war
  */
 public function process(array $data)
 {
     foreach ($this->uniqueConstraints as $constraint) {
         $constraintValue = array();
         foreach ($constraint->getKeys() as $key) {
             // da wir diese reihenfolge nehmen, ist diese immer gleich
             $type = $constraint->getKeyType($key);
             if (!array_key_exists($key, $data)) {
                 throw new WrongDataException(sprintf("In Data ist der Schlüssel '%s' nicht vorhanden. Erwartet: '%s'", $key, $type->getName()));
             }
             $value = $data[$key];
             if (!$this->typeMatcher->isTypeof($value, $type)) {
                 $e = new TypeExpectedException(sprintf("Data %s für Key: '%s' sollte vom Type '%s' sein", \Psc\Code\Code::varInfo($value), $key, $type->getName()));
                 $e->expectedType = $type;
                 throw $e;
             }
             $constraintValue[$key] = $value;
         }
         // schlüssel darf es nicht geben, wert nicht gesetzt kann es nicht geben
         if (($indexEntry = $this->index->get($constraintValue, FALSE, DataInput::THROW_EXCEPTION)) === FALSE) {
             // ok: nicht im index => zum index hinzufügen
             $this->index->set($constraintValue, array_key_exists('identifier', $data) ? $data['identifier'] : TRUE);
         } else {
             throw UniqueConstraintException::factory($constraint->getName(), $this->getStringValue($constraintValue), $constraintValue, !is_bool($indexEntry) ? $indexEntry : NULL);
         }
     }
 }

 public function matchIValue($value)
 {
     if (($p = mb_strtolower($this->part())) === $value) {
         return $this->success($p);
     }
     $this->fail($p . ' matched ' . Code::varInfo($value) . ' nicht');
 }

 /**
  * @return list($threadLink, $threadId);
  */
 public function findThread($boardId, Season $season)
 {
     $this->logger->writeln('Suche Thread für ' . $season . ' in board: ' . $boardId);
     $this->req = new URLRequest('http://www.subcentral.de/index.php?page=Board&boardID=' . $boardId, $this->cookieJar);
     $html = $this->req->init()->process();
     /* wir holen uns den richtigen Thread aus den "wichtigen Themen" */
     $dom = xml::doc($html);
     $res = xml::query($dom, '#stickiesStatus table td.columnTopic div.topic p');
     $stickies = array();
     // das sind nicht alle wegen break!
     foreach ($res as $topicP) {
         $topicP = xml::doc($topicP);
         $topicA = A::first(xml::query($topicP, 'a'));
         $title = (string) $topicA->nodeValue;
         $stickies[] = $title;
         $prefix = xml::query($topicP, 'span.prefix strong');
         if (count($prefix) == 1 && $prefix[0]->nodeValue == '[Subs]' && Preg::match($title, '/(Staffel\\s*' . $season->getNum() . '|S0*' . $season->getNum() . ')/i') > 0) {
             $link = $topicA->getAttribute('href');
             $threadId = (int) Preg::qmatch($link, '/threadId=([0-9]+)/');
             break;
         }
     }
     if (!isset($link)) {
         $pe = new SubcentralException('Pfad nicht gefunden: "#stickiesStatus table td.columnTopic div.topic p a" in ' . $this->req->getURL() . ' ' . Code::varInfo($stickies));
         $e = new SubcentralException('Thread für Staffel: ' . $season->getNum() . ' für Serie: ' . $season->getTvShow()->getTitle() . ' nicht gefunden', 0, $pe);
         $this->logger->writeln($e->getMessage());
         $this->logger->writeln($pe->getMessage());
         throw $e;
     }
     $link = 'http://www.subcentral.de/' . $link;
     return array($link, $threadId);
 }

 public function __construct(array $buttons, TranslationContainer $translationContainer, $flags = NULL)
 {
     $this->translationContainer = $translationContainer;
     $this->buttons = array();
     foreach ($buttons as $button) {
         if ($button === 'save') {
             $this->addSaveButton();
         } elseif ($button === 'insert-open') {
             $this->addInsertOpenButton();
         } elseif ($button === 'save-close') {
             $this->addSaveCloseButton();
         } elseif ($button === 'insert-close') {
             $this->addInsertCloseButton();
         } elseif ($button === 'insert') {
             $this->addInsertButton();
         } elseif ($button === 'reload') {
             $this->addReloadButton();
         } elseif ($button === 'reset') {
             $this->addResetButton();
         } elseif ($button === 'view') {
             $this->addViewButton();
         } elseif ($button === 'preview') {
             $this->addPreviewButton();
         } elseif ($button instanceof \Psc\UI\Button) {
             $this->buttons[] = $button;
         } else {
             throw new \InvalidArgumentException('Unbekannter Parameter in array $buttons (1. Parameter) : ' . Code::varInfo($button));
         }
     }
     if ($flags === NULL) {
         $this->flags = self::ALIGN_RIGHT | self::CLEAR;
     } else {
         $this->flags = $flags;
     }
 }

 /**
  * @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;
 }

 /**
  * Erstellt eine neue Rule durch eine Spezifikation (was so quasi alles sein kann)
  *
  * Die Parameter dieser Funktion sind sehr Variabel
  * Möglicherweise ist es einfacher generate[A-Za-z+]Rule zu benutzen
  */
 public static function generateRule($ruleSpecification)
 {
     $rs = $ruleSpecification;
     if (is_string($rs)) {
         if ($rs == 'nes') {
             return new NesValidatorRule();
         }
         if ($rs == 'id') {
             return new IdValidatorRule();
         }
         if ($rs == 'pi' || $rs == 'pint') {
             return new PositiveIntValidatorRule();
         }
         if ($rs == 'array') {
             return new ArrayValidatorRule();
         }
         if ($rs == 'pi0' || $rs == 'pint0') {
             $rule = new PositiveIntValidatorRule();
             $rule->setZeroAllowed(TRUE);
             return $rule;
         }
         if (S::startsWith($rs, '/') && S::endsWith($rs, '/')) {
             return self::generateRegexpRule($rs);
         }
         $c = '\\' . __NAMESPACE__ . '\\' . ucfirst($rs) . 'ValidatorRule';
         if (class_exists($c)) {
             return new $c();
         }
         throw new \Psc\Exception('Unbekannte Parameter für generateRule ' . Code::varInfo($rs));
     }
     if (is_array($rs)) {
         $num = count($rs);
     }
     throw new \Psc\Exception('Unbekannte Parameter für generateRule ' . Code::varInfo($rs));
 }

 /**
  * Validiert die Daten zu einem Feld
  *
  * gibt die Daten zurück!
  * Wenn das Feld nicht validiert werden, wird eine Exception geworfen!
  * @throws ValidatorException wenn die Daten nicht zum Feld passen
  *
  * ist $flags OPTIONAL gesetzt und wird die Rule eine EmptyDataException werfen, wird der DefaultWert (normal: NULL) der Exception zurückgegeben
  * wenn $this->dataProvider gesetzt ist, wird IMMER $this->dataProvider->getValidatorData() benutzt und nicht der $data Parameter
  */
 public function validate($field, $data = NULL, $flags = 0x0)
 {
     $key = $this->getKey($field);
     if (isset($this->dataProvider)) {
         $data = $this->dataProvider->getValidatorData($field);
     }
     if ($this->hasField($field)) {
         try {
             foreach ($this->rules[$key] as $rule) {
                 $data = $rule->validate($data);
                 // wenn wir hier data zurückgeben, können wir die rules chainen
             }
         } catch (EmptyDataException $e) {
             if (($flags & self::OPTIONAL) == self::OPTIONAL || $this->isOptional($field)) {
                 return $e->getDefaultValue();
             } else {
                 if ($e->getMessage() == NULL) {
                     $e->setMessage(sprintf($this->standardEmptyMessage, $this->getKey($field)));
                 }
                 throw $this->convertToValidatorException($e, $field, $data);
             }
         } catch (\Exception $e) {
             throw $this->convertToValidatorException($e, $field, $data);
         }
     } else {
         throw new \Psc\Exception('Feld: ' . Code::varInfo($field) . ' ist dem Validator nicht bekannt.');
     }
     return $data;
 }

 public function get($identifier)
 {
     try {
         return $this->repository->hydrate($identifier);
     } catch (\Psc\Doctrine\EntityNotFoundException $e) {
         throw new NoUserException('User mit dem Identifier: ' . Code::varInfo($identifier) . ' nicht gefunden.', 0, $e);
     }
 }

 /**
  * @param array Webforge\Types[] Schlüssel sind Namen der Felder (Ebenen getrennt mit .), Werte sind Webforge\Types\Type-Objekte
  */
 public function addTypesFromArray(array $types)
 {
     foreach ($types as $field => $type) {
         if (!$type instanceof Type) {
             throw new TypeExpectedException('Instances from Type as values from the array expected. ' . Code::varInfo($type) . ' was provided.');
         }
         $this->setFieldType($field, $type);
     }
     return $this;
 }

 /**
  * $message->setTo(self::recipient('p.scheit@ps-webforge.com'));
  * 
  * @return korrektes Format für Message::set(From|To|Bcc|Cc)
  */
 public static function recipient($recipient)
 {
     if (is_string($recipient)) {
         return $recipient;
     }
     if (is_array($recipient)) {
         return $recipient;
     }
     // @TODO checks?
     throw new Exception('Unbekannter Parameter: ' . Code::varInfo($recipient));
 }

 public function export()
 {
     $export = array();
     foreach ($this->toArray() as $key => $element) {
         if (!$element instanceof Exportable) {
             throw new Exception('Jedes Element einer ArrayExportCollection muss ein Exportable sein. ' . Code::varInfo($element));
         }
         $export[$key] = $element->export();
     }
     return $export;
 }

 protected function getThumbnailFormat($format)
 {
     if (array_key_exists($format, $this->formats)) {
         $arguments = $this->formats[$format];
         $options = array();
         if (count($arguments) == 4) {
             $options = array_pop($arguments);
         }
         return (object) array('arguments' => $arguments, 'options' => $options);
     }
     throw new \Psc\Exception('Unbekanntes Format: ' . Code::varInfo($format));
 }

 /**
  *
  * $hydrator = new Hydrator('FoodTag', $doctrinePackage);
  * $tags = $hydrator->byList(array('hot','special','spicy'), 'label');
  * 
  * @return array
  */
 public function byList(array $list, $field, $checkCardinality = TRUE, &$found = NULL)
 {
     if ($list == NULL) {
         return array();
     }
     $result = $this->getRepository()->findBy(array($field => $list));
     $found = count($result);
     if ($checkCardinality && $found != count($list)) {
         throw new \Psc\Exception('Es konnten nicht alle Felder aus der Liste geladen werden. Gefunden: ' . $found . ' in der Liste waren aber: ' . count($list) . ' Liste: ' . Code::varInfo($list));
     }
     return $result;
 }

 public function setCode($code, $reason = NULL)
 {
     if (!is_integer($code)) {
         throw new \InvalidArgumentException('Code muss ein Integer sein: ' . Code::varInfo($code));
     }
     $this->code = $code;
     if (!array_key_exists($this->code, self::$reasons)) {
         throw new \InvalidArgumentException('Response Code: ' . $code . ' ist nicht bekannt');
     }
     $this->reason = $reason ?: self::$reasons[$this->code];
     return $this;
 }