/** * @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; }
/** * Constructor * * @param Queue $queue * @param Exchange[] $exchanges * @param int $waitMillis * @param string $appId */ public function __construct(Queue $queue, array $exchanges, int $waitMillis = 100, string $appId = '') { Assertion::min($waitMillis, 1); Assertion::notEmpty($exchanges, 'No exchanges given'); Assertion::allIsInstanceOf($exchanges, Exchange::class); $this->queue = $queue; $this->exchanges = $exchanges; $this->waitMillis = $waitMillis; $this->appId = $appId; }
/** * @param \databox[] $databoxes * @return \databox[] */ public function filterAvailableDataboxes(array $databoxes) { Assertion::allIsInstanceOf($databoxes, \databox::class); if (!$this->isRestricted()) { return $databoxes; } $available = array_flip($this->cache->fetch('available_databoxes')); return array_filter($databoxes, function (\databox $databox) use($available) { return isset($available[$databox->get_sbas_id()]); }); }
/** * @param StructureItem[] $aStructureItemCollection * @throws \InvalidArgumentException */ public function __construct(array $aStructureItemCollection) { Assertion::allIsInstanceOf($aStructureItemCollection, 'GingerCore\\Model\\JsonWDL\\Action\\StructureItem'); foreach ($aStructureItemCollection as $structureItem) { if (array_key_exists($structureItem->pathWithKey(), $this->structureItems)) { throw new \InvalidArgumentException(sprintf('Duplicate path detected: %s', $structureItem->pathWithKey())); } $this->structureItems[$structureItem->pathWithKey()] = $structureItem; } ksort($this->structureItems); }
/** * @param Email|Email[] $recipients * @param string $subject * @param string $body * @param string $from * @param string $fromName * @param array $bcc */ public function __construct($recipients, $subject, $body = '', $from = null, $fromName = null, $bcc = []) { $transformedRecipients = is_array($recipients) ? $recipients : [$recipients]; Assertion::nullOrEmail($from, "Invalid FROM email"); Assertion::allIsInstanceOf($transformedRecipients, Email::class, "Invalid recipient(s)"); $this->recipients = $transformedRecipients; $this->subject = $subject; $this->body = $body; $this->from = $from; $this->fromName = $fromName; $this->bcc = $bcc; }
/** * Check if user has all required permissions. * * @param Permission[] $permissions Permissions which are required. * * @return bool */ public function hasPermissions($permissions) { Assertion::allIsInstanceOf($permissions, 'Netzmacht\\Workflow\\Security\\Permission'); $granted = array(); foreach ($permissions as $index => $permission) { foreach ($this->roles as $role) { if ($role->hasPermission($permission)) { $granted[$index] = true; continue; } } } return count($granted) === count($permissions); }
/** * Constructor. * * @param Identifier $identifier * @param string $name * @param Category[] $categories * @param Tip\TipGroup[] $tipGroups * @param Photo\PhotoGroup[] $photosGroups * @param Contact $contact * @param Location $location * @param Detail $details */ public function __construct(Identifier $identifier, $name, array $categories, array $tipGroups, array $photosGroups, Contact $contact, Location $location, Detail $details) { \Assert\that($name)->string()->notEmpty(); Assertion::allIsInstanceOf($categories, Category::class); Assertion::allIsInstanceOf($tipGroups, Tip\TipGroup::class); Assertion::allIsInstanceOf($photosGroups, Photo\PhotoGroup::class); $this->identifier = $identifier; $this->name = $name; $this->categories = $categories; $this->tipGroups = $tipGroups; $this->photoGroups = $photosGroups; $this->contact = $contact; $this->location = $location; $this->details = $details; }
public function __construct(array $fields = [], array $flags = [], array $metadata_tags = []) { Assertion::allIsInstanceOf($fields, Field::class); Assertion::allIsInstanceOf($flags, Flag::class); Assertion::allIsInstanceOf($metadata_tags, Tag::class); foreach ($fields as $field) { $this->add($field); } foreach ($flags as $flag) { $this->flags[$flag->getName()] = $flag; } foreach ($metadata_tags as $tag) { $this->metadata_tags[$tag->getName()] = $tag; } }
public function __construct($name, $type, array $options = []) { $this->name = (string) $name; $this->type = $type; $this->is_searchable = \igorw\get_in($options, ['searchable'], true); $this->is_private = \igorw\get_in($options, ['private'], false); $this->facet = \igorw\get_in($options, ['facet']); $this->thesaurus_roots = \igorw\get_in($options, ['thesaurus_roots'], null); $this->used_by_collections = \igorw\get_in($options, ['used_by_collections'], []); Assertion::boolean($this->is_searchable); Assertion::boolean($this->is_private); if ($this->facet !== self::FACET_DISABLED) { Assertion::integer($this->facet); } if ($this->thesaurus_roots !== null) { Assertion::allIsInstanceOf($this->thesaurus_roots, Concept::class); } Assertion::allScalar($this->used_by_collections); }
/** * @param EventDescription[] $anEventDescriptionsCollection */ public function __construct(array $anEventDescriptionsCollection) { Assertion::allIsInstanceOf($anEventDescriptionsCollection, 'GingerCore\\Model\\JsonWDL\\Action\\EventDescription'); $this->eventDescriptions = $anEventDescriptionsCollection; }
/** * @param FireResult[] $fireResults */ private function __construct(array $fireResults) { Assertion::allIsInstanceOf($fireResults, FireResult::class); $this->fireResults = $fireResults; }
public function testAllWithComplexAssertionThrowsExceptionOnElementThatFailsAssertion() { $this->setExpectedException('Assert\\AssertionFailedException', 'Assertion failed', Assertion::INVALID_INSTANCE_OF); Assertion::allIsInstanceOf(array(new \stdClass(), new \stdClass()), 'PDO', 'Assertion failed', 'foos'); }
/** * Restore an existing item. * * @param EntityId $entityId The entity id. * @param mixed $entity The entity. * @param State[] $stateHistory Set or already passed states. * * @return Item */ public static function reconstitute(EntityId $entityId, $entity, $stateHistory) { Assertion::allIsInstanceOf($stateHistory, 'Netzmacht\\Workflow\\Flow\\State'); $item = self::initialize($entityId, $entity); // replay states foreach ($stateHistory as $state) { $item->apply($state); } return $item; }
/** * JWKSets constructor. * * @param \Jose\Object\JWKSetInterface[] $jwksets */ public function __construct(array $jwksets = []) { Assertion::allIsInstanceOf($jwksets, JWKSetInterface::class); $this->jwksets = $jwksets; }
/** * @param array $phoneNumbers */ private function __construct(array $phoneNumbers = []) { Guard::allIsInstanceOf($phoneNumbers, 'GingerPayments\\Payment\\Order\\Customer\\PhoneNumber'); $this->phoneNumbers = $phoneNumbers; }
/** * @param MetadataEnricher[] $metadataEnrichers */ public function __construct(array $metadataEnrichers) { Assertion::allIsInstanceOf($metadataEnrichers, MetadataEnricher::class); $this->metadataEnrichers = $metadataEnrichers; }