PHP Assertion::notEmpty方法代碼示例

 /**
  * @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 string $workflowName
  * @param string $workflowId
  * @return CreateWorkflow
  */
 public static function withName($workflowName, $workflowId)
 {
     Assertion::string($workflowName);
     Assertion::notEmpty($workflowName);
     Assertion::uuid($workflowId);
     return new self(__CLASS__, ['workflow_id' => $workflowId, 'name' => $workflowName]);
 }

 public function __construct($templateId, $id)
 {
     Assertion::notEmpty($templateId);
     Assertion::string($id);
     $this->id = $id;
     $this->templateId = $templateId;
 }

 /**
  * CreateUser constructor.
  *
  * @param string $userName
  * @param string $password
  */
 public function __construct($userName = '', $password = '')
 {
     Assertion::notEmpty($userName, 'Username is a required field to create a user');
     Assertion::notEmpty($password, 'Password is a required field to create a user');
     $this->userName = $userName;
     $this->password = $password;
 }

 /**
  * @param string $messageName
  * @return string
  */
 public static function normalize($messageName)
 {
     Assertion::notEmpty($messageName);
     Assertion::string($messageName);
     $search = array(static::MESSAGE_NAME_PREFIX, "-", "\\", "/", " ");
     return strtolower(str_replace($search, "", $messageName));
 }

 /**
  * @param $name
  */
 public function __construct($name)
 {
     Assertion::string($name, 'StreamName must be a string');
     Assertion::notEmpty($name, 'StreamName must not be empty');
     Assertion::maxLength($name, 200, 'StreamName should not be longer than 200 chars');
     $this->name = $name;
 }

 protected function _validateIpnListeners()
 {
     Assertion::notEmpty($this->ipnListeners);
     foreach ($this->ipnListeners as $ipn_listener) {
         Assertion::isInstanceOf($ipn_listener, PaymentListener::class);
     }
 }

 /**
  * Устанавливает описание gitlab'a
  *
  * @param string $token
  *
  * @return $this
  * @throws \Assert\AssertionFailedException
  */
 public function setToken($token)
 {
     Assertion::notEmpty($token);
     Assertion::string($token);
     $this->token = $token;
     return $this;
 }

 /**
  * Returns a project config instance.
  *
  * @param string $project Project name
  *
  * @return Config
  */
 public function getProjectConfig($project)
 {
     Assertion::string($project);
     Assertion::notEmpty($project);
     $config = $this->configLoader->load(array($this->getConfigFilePath($project)));
     return $config;
 }

 /**
  * AddUserToGroup constructor.
  *
  * @param string $userName
  * @param string $groupId
  */
 public function __construct($userName = '', $groupId = '')
 {
     Assertion::notEmpty($userName, 'Username is a required field to add a user to a group');
     Assertion::notEmpty($groupId, 'Group id is a required field to add a user to a group');
     $this->userName = $userName;
     $this->groupId = $groupId;
 }

 private function __construct(ExpenseListId $id, $name, AccountId $accountId)
 {
     Assertion::notEmpty($name);
     $this->name = $name;
     $this->id = $id;
     $this->accountId = $accountId;
 }

 /**
  * ActivityTest constructor.
  * @param User      $user
  * @param \DateTime $created
  * @param integer   $activities
  */
 public function __construct(User $user, \DateTime $created, $activities)
 {
     Assertion::integer($activities);
     Assertion::notEmpty($created);
     $this->dateTime = $created;
     $this->activities = $activities;
     $this->user = $user;
 }

 public function getField(string $name) : Field
 {
     $fields = array_filter($this->fields, function (Field $field) use($name) : bool {
         return $field->getName() === $name;
     });
     Assertion::notEmpty($fields);
     return reset($fields);
 }

 /**
  * @param array $jsonDecodedData
  * @return Payload
  */
 public static function fromJsonDecodedData(array $jsonDecodedData)
 {
     Assertion::keyExists($jsonDecodedData, 'typeClass');
     Assertion::keyExists($jsonDecodedData, 'data');
     Assertion::notEmpty($jsonDecodedData['typeClass']);
     Assertion::string($jsonDecodedData['typeClass']);
     return new static($jsonDecodedData['typeClass'], $jsonDecodedData['data']);
 }

 public function consume($queue_name, Closure $message_callback)
 {
     Assertion::string($queue_name);
     Assertion::notEmpty($queue_name);
     $channel = $this->getChannel();
     $channel->basic_qos(null, 1, null);
     $channel->basic_consume($queue_name, false, true, false, false, false, $message_callback);
     return $channel;
 }