PHP Assertion::allIsInstanceOf方法代码示例

 /**
  * @param Field[] $elements
  * @param Ship[] $ships
  */
 private function __construct(array $elements, array $ships = [])
 {
     Assertion::allIsInstanceOf($elements, Field::class);
     Assertion::allIsInstanceOf($ships, Ship::class);
     $this->elements = $elements;
     $this->ships = $ships;
 }

 /**
  * @param databox_field[] $fields
  */
 public function __construct($fields = [])
 {
     Assertion::allIsInstanceOf($fields, databox_field::class);
     foreach ($fields as $field) {
         $this->add_element($field);
     }
 }

 public static function filterByValueCompatibility(array $list, $value)
 {
     Assertion::allIsInstanceOf($list, Typed::class);
     $is_numeric = is_numeric($value);
     $is_valid_date = RecordHelper::validateDate($value);
     $filtered = [];
     foreach ($list as $item) {
         switch ($item->getType()) {
             case Mapping::TYPE_FLOAT:
             case Mapping::TYPE_DOUBLE:
             case Mapping::TYPE_INTEGER:
             case Mapping::TYPE_LONG:
             case Mapping::TYPE_SHORT:
             case Mapping::TYPE_BYTE:
                 if ($is_numeric) {
                     $filtered[] = $item;
                 }
                 break;
             case Mapping::TYPE_DATE:
                 if ($is_valid_date) {
                     $filtered[] = $item;
                 }
                 break;
             case Mapping::TYPE_STRING:
             default:
                 $filtered[] = $item;
         }
     }
     return $filtered;
 }

 /**
  * Construct.
  *
  * @param TransitionHandlerFactory $handlerFactory  The transition handler factory.
  * @param StateRepository          $stateRepository The state repository.
  * @param Workflow[]               $workflows       The set of managed workflows.
  */
 public function __construct(TransitionHandlerFactory $handlerFactory, StateRepository $stateRepository, $workflows = array())
 {
     Assertion::allIsInstanceOf($workflows, 'Netzmacht\\Workflow\\Flow\\Workflow');
     $this->workflows = $workflows;
     $this->handlerFactory = $handlerFactory;
     $this->stateRepository = $stateRepository;
 }

 /**
  * @param array $processingTypes
  * @param bool $supportAll
  */
 private function __construct(array $processingTypes, $supportAll)
 {
     Assertion::allIsInstanceOf($processingTypes, Prototype::class);
     Assertion::boolean($supportAll);
     $this->supportedProcessingTypes = $processingTypes;
     $this->supportAllTypes = $supportAll;
 }

 /**
  * @param SnapshotStore $snapshotStore
  * @param AggregateRepository[] $aggregateRepositories
  */
 public function __construct(SnapshotStore $snapshotStore, array $aggregateRepositories)
 {
     Assertion::notEmpty($aggregateRepositories);
     Assertion::allIsInstanceOf($aggregateRepositories, AggregateRepository::class);
     $this->snapshotStore = $snapshotStore;
     $this->aggregateRepositories = $aggregateRepositories;
 }

 /** @param Processor[] $processors */
 public function __construct(HttpClient $httpClient, array $processors)
 {
     Assertion::allIsInstanceOf($processors, Processor::class);
     $this->httpClient = $httpClient;
     foreach ($processors as $processor) {
         $this->processors[$processor->getContentType()] = $processor;
     }
 }

 /**
  * @param TechnicalData[] $data
  */
 public function __construct($data = [])
 {
     Assertion::allIsInstanceOf($data, TechnicalData::class);
     $this->data = [];
     foreach ($data as $technicalData) {
         $this->data[$technicalData->getName()] = $technicalData;
     }
 }

 /**
  * Add multiple conditions.
  *
  * @param array $conditions Array of conditions being added.
  *
  * @return $this
  *
  * @throws \Assert\InvalidArgumentException If array contains an invalid condition.
  */
 public function addConditions(array $conditions)
 {
     Assertion::allIsInstanceOf($conditions, 'Netzmacht\\Workflow\\Flow\\Condition\\Transition\\Condition');
     foreach ($conditions as $condition) {
         $this->addCondition($condition);
     }
     return $this;
 }

 /**
  * @param string        $aType
  * @param array         $aProcessStepCollection
  * @param AgentOptions  $anOptions
  */
 public function __construct($aType, array $aProcessStepCollection, AgentOptions $anOptions = null)
 {
     Assertion::inArray($aType, array(self::SEQUENCE, self::SPLIT, self::FORK, self::LOOP));
     Assertion::allIsInstanceOf($aProcessStepCollection, 'GingerCore\\Model\\JsonWDL\\ProcessStep');
     $this->type = $aType;
     $this->processSteps = $aProcessStepCollection;
     $this->options = is_null($anOptions) ? new AgentOptions(array()) : $anOptions;
 }

 /**
  * Constructor.
  *
  * @param string $name
  * @param string $type
  * @param Photo[] $photos
  */
 public function __construct($name, $type, array $photos)
 {
     \Assert\that($name)->string()->notEmpty();
     \Assert\that($type)->string()->notEmpty();
     Assertion::allIsInstanceOf($photos, Photo::class);
     $this->name = $name;
     $this->type = $type;
     $this->photos = $photos;
 }

 /**
  * @param FieldNode[]    $fields
  * @param Link[]         $links
  * @param ResourceNode[] $resources
  */
 public function __construct(array $fields, array $links = [], array $resources = [])
 {
     Assertion::allIsInstanceOf($fields, FieldNode::class);
     Assertion::allIsInstanceOf($links, Link::class);
     Assertion::allIsInstanceOf($resources, ResourceNode::class);
     $this->fields = $fields;
     $this->links = $links;
     $this->resources = $resources;
 }

 /**
  * Constructor.
  *
  * @param string $name
  * @param string $type
  * @param Tip[] $tips
  */
 public function __construct($name, $type, array $tips)
 {
     \Assert\that($name)->string()->notEmpty();
     \Assert\that($type)->string()->notEmpty();
     Assertion::allIsInstanceOf($tips, Tip::class);
     $this->name = $name;
     $this->type = $type;
     $this->tips = $tips;
 }

 /**
  * @param Entity[] $entities
  */
 public function __construct(array $entities = array())
 {
     Assertion::allIsInstanceOf($entities, '\\OpenConext\\Value\\Saml\\Entity');
     foreach ($entities as $entity) {
         if ($this->contains($entity)) {
             continue;
         }
         $this->entities[] = $entity;
     }
 }

 /**
  * Consider if role has a set of permissions.
  *
  * @param Permission[] $permissions Set of permissions.
  *
  * @return bool
  */
 public function hasPermissions($permissions)
 {
     Assertion::allIsInstanceOf($permissions, 'Netzmacht\\Workflow\\Security\\Permission');
     foreach ($permissions as $permission) {
         if (!$this->hasPermission($permission)) {
             return false;
         }
     }
     return true;
 }