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