PHP Assertion::choice方法代码示例

 /**
  * @param string $direction
  * @param int $days
  */
 public function __construct($direction, $days)
 {
     Assertion::integerish($days);
     Assertion::choice($direction, [self::DIRECTION_PAST, self::DIRECTION_FUTURE]);
     $this->direction = $direction;
     $this->days = (int) $days;
 }

 /**
  * @param string $resolution
  *
  * @throws \InvalidArgumentException
  *
  * @return static
  */
 public function withResolution($resolution)
 {
     $choices = [PriceInterface::RESOLUTION_HD, PriceInterface::RESOLUTION_SD];
     Assertion::choice($resolution, $choices);
     $instance = clone $this;
     $instance->resolution = $resolution;
     return $instance;
 }

 /**
  * @param string $allowEmbed
  *
  * @throws \InvalidArgumentException
  *
  * @return static
  */
 public function withAllowEmbed($allowEmbed)
 {
     $choices = [PlayerLocationInterface::ALLOW_EMBED_NO, PlayerLocationInterface::ALLOW_EMBED_YES];
     Assertion::choice($allowEmbed, $choices);
     $instance = clone $this;
     $instance->allowEmbed = $allowEmbed;
     return $instance;
 }

 /**
  * Constructor.
  *
  * @param Identifier $identifier
  * @param \DateTimeImmutable $createdAt
  * @param string $url
  * @param string $visibility
  */
 public function __construct(Identifier $identifier, \DateTimeImmutable $createdAt, $url, $visibility)
 {
     Assertion::choice($visibility, static::$visibilityEnum);
     Assertion::url($url);
     $this->identifier = $identifier;
     $this->createdAt = $createdAt;
     $this->url = $url;
     $this->visibility = $visibility;
 }

 /**
  * @param int $gender
  * @param string $firstName
  * @param string $lastName
  * @param string $email
  */
 public function __construct($gender, $firstName, $lastName, $email)
 {
     Assertion::choice($gender, [self::GENDER_MALE, self::GENDER_FEMALE]);
     Assertion::notEmpty($firstName);
     Assertion::notEmpty($lastName);
     Assertion::email($email);
     $this->gender = $gender;
     $this->firstName = $firstName;
     $this->lastName = $lastName;
     $this->email = $email;
 }

 /**
  * @param string $result
  * @param Coords $target
  * @param Coords $startPoint
  * @param Coords $endPoint
  */
 private function __construct($result, Coords $target, Coords $startPoint = null, Coords $endPoint = null)
 {
     Assertion::choice($result, [static::HIT, static::MISS, static::SANK, static::WIN]);
     if (in_array($result, [static::SANK, static::WIN])) {
         Assertion::notNull($startPoint);
         Assertion::notNull($endPoint);
     }
     $this->result = $result;
     $this->startPoint = $startPoint;
     $this->endPoint = $endPoint;
     $this->target = $target;
 }

 /**
  * Create a Config.
  *
  * @param string $sender Sender code to use.
  * @param string $wsdl WSDL file to use (local path or URL), null means default depending on the debug mode.
  * @param int $timeoutSec (Optional) Timeout in seconds, null means no timeout.
  * @param string $operatingMode (Optional) Operating mode, default is "P" for production. "D" = Development, "T" = Test.
  * @param array $soapClientOptions (Optional) Options for SoapClient.
  * @param string $receiver (Optional) Receiver code to use, default: YELLOWCUBE.
  */
 function __construct($sender, $wsdl = null, $timeoutSec = null, $operatingMode = 'P', array $soapClientOptions = array(), $receiver = 'YELLOWCUBE')
 {
     Assertion::notEmpty($sender, 'Sender must be set.');
     Assertion::nullOrNotEmpty($wsdl, 'WSDL must be set.');
     Assertion::nullOrInteger($timeoutSec, 'Timeout must be null or an integer in seconds.');
     Assertion::choice($operatingMode, array('T', 'D', 'P'), 'Operating mode must be "T", "D" or "P".');
     Assertion::notEmpty($receiver, 'Receiver must be set.');
     $this->sender = $sender;
     $this->wsdl = $wsdl;
     $this->timeoutSec = $timeoutSec;
     $this->operatingMode = $operatingMode;
     $this->soapClientOptions = $soapClientOptions;
     $this->receiver = $receiver;
 }

 /**
  * @param UuidInterface $id
  * @param int $type
  * @param string $street
  * @param string $streetNumber
  * @param string $postalCode
  * @param string $city
  * @param string $state
  * @param string $country
  * @param string $phone
  */
 public function __construct(UuidInterface $id, $type, $street, $streetNumber, $postalCode, $city, $state, $country, $phone)
 {
     Assertion::uuid($id->toString());
     Assertion::choice($type, [self::TYPE_BILLING, self::TYPE_SHIPPING]);
     Assertion::notEmpty($street);
     Assertion::notEmpty($streetNumber);
     Assertion::notEmpty($postalCode);
     Assertion::notEmpty($city);
     Assertion::notEmpty($state);
     Assertion::notEmpty($country);
     Assertion::notEmpty($phone);
     $this->id = $id;
     $this->type = $type;
     $this->street = $street;
     $this->streetNumber = $streetNumber;
     $this->postalCode = $postalCode;
     $this->city = $city;
     $this->state = $state;
     $this->country = $country;
     $this->phone = $phone;
 }

 public function __construct($filters, $offset, $limit, $sortField, $sortOrder, $isPaginated)
 {
     Assertion::isArray($filters, "Invalid filters");
     Assertion::integerish($limit, "Invalid limit");
     Assertion::integerish($offset, "Invalid offset");
     Assertion::nullOrString($sortField, "Invalid sort field");
     Assertion::choice($sortOrder, [null, self::ORDER_ASC, self::ORDER_DESC], "Invalid sort order");
     Assertion::boolean($isPaginated, "Invalid value for isPaginated");
     if ($limit < 0) {
         throw new \InvalidArgumentException("Invalid limit");
     }
     if ($offset < 0) {
         throw new \InvalidArgumentException("Invalid offset");
     }
     $this->filters = $filters;
     $this->offset = (int) $offset;
     $this->limit = (int) $limit;
     $this->sortField = $sortField;
     $this->sortOrder = $sortOrder;
     $this->isPaginated = (bool) $isPaginated;
 }

 /**
  * @param string $live
  *
  * @throws \InvalidArgumentException
  *
  * @return static
  */
 public function withLive($live)
 {
     $choices = [VideoInterface::LIVE_NO, VideoInterface::LIVE_YES];
     Assertion::choice($live, $choices);
     $instance = clone $this;
     $instance->live = $live;
     return $instance;
 }

 /**
  * @param string $relationship
  *
  * @throws \InvalidArgumentException
  */
 public function __construct($relationship)
 {
     $choices = [PlatformInterface::RELATIONSHIP_ALLOW, PlatformInterface::RELATIONSHIP_DENY];
     Assertion::choice($relationship, $choices);
     $this->relationship = $relationship;
 }

 /**
  * @param string $value
  */
 private function __construct($value)
 {
     Guard::choice($value, $this->possibleValues());
     $this->value = $value;
 }

 private function __construct($type)
 {
     Assertion::choice($type, ['read', 'write']);
     $this->type = $type;
 }

 /**
  * @param string $changeFrequency
  *
  * @throws \InvalidArgumentException
  *
  * @return static
  */
 public function withChangeFrequency($changeFrequency)
 {
     $choices = [UrlInterface::CHANGE_FREQUENCY_ALWAYS, UrlInterface::CHANGE_FREQUENCY_HOURLY, UrlInterface::CHANGE_FREQUENCY_DAILY, UrlInterface::CHANGE_FREQUENCY_WEEKLY, UrlInterface::CHANGE_FREQUENCY_MONTHLY, UrlInterface::CHANGE_FREQUENCY_YEARLY, UrlInterface::CHANGE_FREQUENCY_NEVER];
     Assertion::choice($changeFrequency, $choices);
     $instance = clone $this;
     $instance->changeFrequency = $changeFrequency;
     return $instance;
 }

 /**
  * @param string $algo
  */
 public function __construct($algo)
 {
     Assertion::choice($algo, hash_algos());
     $this->algo = $algo;
 }