PHP Assert::isInstance方法代码示例

 public static function generateLinks(array $classes)
 {
     $links = [];
     foreach ($classes as $class) {
         Assert::isInstance($class, 'MetaClass');
         foreach ($class->getProperties() as $property) {
             if ($property->getType() instanceof ObjectType && $property->getType()->getClassName() && $property->getRelation()) {
                 switch ($property->getRelation()->getId()) {
                     case MetaRelation::ONE_TO_ONE:
                         $rel = ' -- ';
                         break;
                     case MetaRelation::ONE_TO_MANY:
                         $rel = ' *-- ';
                         break;
                     case MetaRelation::MANY_TO_MANY:
                         $rel = ' *--* ';
                         break;
                     default:
                         throw new WrongStateException();
                         break;
                 }
                 $links[] = $class->getName() . $rel . $property->getType()->getClassName() . "\n";
             }
         }
         $links = array_unique($links);
     }
     return implode("", $links) . "\n";
 }

 public function import($scope)
 {
     if (!$this->className) {
         throw new WrongStateException("no class defined for PrimitiveIdentifier '{$this->name}'");
     }
     $className = $this->className;
     if (isset($scope[$this->name]) && $scope[$this->name] instanceof $className) {
         $value = $scope[$this->name];
         $this->raw = $value->getId();
         $this->setValue($value);
         return $this->imported = true;
     }
     $result = parent::import($scope);
     if ($result === true) {
         try {
             $result = $this->actualImportValue($this->value);
             Assert::isInstance($result, $className);
             $this->value = $result;
             return true;
         } catch (WrongArgumentException $e) {
             // not imported
         } catch (ObjectNotFoundException $e) {
             // not imported
         }
         $this->value = null;
         return false;
     }
     return $result;
 }

 /**
  * @param string $path
  * @return DBTestCreator
  */
 public function setSchemaPath($path)
 {
     require $path;
     Assert::isTrue(isset($schema));
     Assert::isInstance($schema, 'DBSchema');
     $this->schema = $schema;
     return $this;
 }

 /**
  * @throws WrongArgumentException
  * @return PrimitiveEnum
  **/
 public function of($class)
 {
     $className = $this->guessClassName($class);
     Assert::classExists($className);
     Assert::isInstance($className, 'Enum');
     $this->className = $className;
     return $this;
 }

 public function send(Message $message)
 {
     if (!$this->queue) {
         throw new WrongStateException('you must set the queue first');
     }
     Assert::isInstance($message, 'TextMessage');
     $this->getStream()->write($message->getTimestamp()->toString() . "\t" . str_replace(PHP_EOL, ' ', $message->getText()) . PHP_EOL);
 }

 public function getBitmask($config)
 {
     Assert::isInstance($config, 'AMQPExchangeConfig');
     $bitmask = parent::getBitmask($config);
     if ($config->getInternal()) {
         $bitmask = $bitmask | AMQP_INTERNAL;
     }
     return $bitmask;
 }

 /**
  * @return PrimitiveEnumList
  **/
 public function setValue($value)
 {
     if ($value) {
         Assert::isArray($value);
         Assert::isInstance(current($value), 'Enum');
     }
     $this->value = $value;
     return $this;
 }

 public function __construct(Identifiable $parent, GenericDAO $dao, $lazy = true)
 {
     Assert::isBoolean($lazy);
     $this->parent = $parent;
     $this->lazy = $lazy;
     $this->dao = $dao;
     Assert::isInstance($dao->getObjectName(), 'Identifiable');
     $this->comparator = SerializedObjectComparator::me();
 }

 public function getBitmask($config)
 {
     Assert::isInstance($config, 'AMQPQueueConfig');
     $bitmask = parent::getBitmask($config);
     if ($config->getExclusive()) {
         $bitmask = $bitmask | AMQP_EXCLUSIVE;
     }
     return $bitmask;
 }

 public function compare($one, $two)
 {
     Assert::isInstance($one, 'Identifiable');
     Assert::isInstance($two, 'Identifiable');
     $oneId = $one->getId();
     $twoId = $two->getId();
     if ($oneId === $twoId) {
         return 0;
     }
     return $oneId < $twoId ? -1 : 1;
 }

 /**
  * @throws WrongArgumentException
  * @return AMQPPool
  **/
 public function addLink($name, AMQP $amqp)
 {
     if (isset($this->pool[$name])) {
         throw new WrongArgumentException("amqp link with name '{$name}' already registered");
     }
     if ($this->pool) {
         Assert::isInstance($amqp, current($this->pool));
     }
     $this->pool[$name] = $amqp;
     return $this;
 }

 public function compare($one, $two)
 {
     Assert::isInstance($one, 'Date');
     Assert::isInstance($two, 'Date');
     $stamp1 = $one->toStamp();
     $stamp2 = $two->toStamp();
     if ($stamp1 == $stamp2) {
         return 0;
     }
     return $stamp1 < $stamp2 ? -1 : 1;
 }

 public function getBitmask($config)
 {
     Assert::isInstance($config, 'AMQPOutgoingMessage');
     $bitmask = 0;
     if ($config->getMandatory()) {
         $bitmask = $bitmask | AMQP_MANDATORY;
     }
     if ($config->getImmediate()) {
         $bitmask = $bitmask | AMQP_IMMEDIATE;
     }
     return $bitmask;
 }

 public function cloneInnerBuilder($property)
 {
     $mapping = $this->getFormMapping();
     Assert::isIndexExists($mapping, $property);
     $primitive = $mapping[$property];
     Assert::isInstance($primitive, 'PrimitiveForm');
     $result = new $this($primitive->getProto());
     if (isset($this->limitedPropertiesList[$primitive->getName()])) {
         $result->setLimitedPropertiesList($this->limitedPropertiesList[$primitive->getName()]);
     }
     return $result;
 }

 public static function getIdsArray($objectsList)
 {
     $out = array();
     if (!$objectsList) {
         return $out;
     }
     Assert::isInstance(current($objectsList), 'Identifiable', 'only identifiable lists accepted');
     foreach ($objectsList as $object) {
         $out[] = $object->getId();
     }
     return $out;
 }