PHP Assert::nullOrString方法代码示例

 /**
  * {@inheritdoc}
  */
 public function startConversation(PersonInterface $sender, $recipient, $body, $subject = null)
 {
     if (!is_array($recipient) && !$recipient instanceof \Traversable) {
         $recipient = [$recipient];
     }
     Assert::allIsInstanceOf($recipient, 'FOS\\Message\\Model\\PersonInterface', '$recipient expected ether an instance or a collection of PersonInterface in Sender::startConversation().');
     Assert::string($body, '$body expected a string in Sender::startConversation(). Got: %s');
     Assert::nullOrString($subject, '$subject expected either a string or null in Sender::startConversation(). Got: %s');
     // Create conversation and message
     $conversation = $this->createAndPersistConversation($subject);
     $message = $this->createAndPersistMessage($conversation, $sender, $body);
     // Add the recipients links
     foreach ($recipient as $person) {
         $this->createAndPersistConversationPerson($conversation, $person);
         $this->createAndPersistMessagePerson($message, $person, false);
     }
     // Add the sender link
     $this->createAndPersistConversationPerson($conversation, $sender);
     $this->createAndPersistMessagePerson($message, $sender, true);
     // Flush the previously persisted entities
     $this->driver->flush();
     // Dispatch the event
     $this->dispatchConversationEvent($conversation, $message);
     return $conversation;
 }

 private function doPut($token, $payload, $user = null)
 {
     Assert::string($token, "Token must be a string. Got: %s");
     Assert::string($payload, "Payload must be a string. Got: %s");
     Assert::nullOrString($user, "User must be a string or null. Got: %s");
     $path = $this->docroot . "/.well-known/acme-challenge";
     $realpath = realpath($path);
     if (!realpath($this->docroot)) {
         throw new ChallengeStoreException("Document root doesn't exist: '{$this->docroot}'");
     }
     if (!$realpath && !@mkdir($path, 0755, true)) {
         throw new ChallengeStoreException("Couldn't create public directory to serve the challenges: '{$path}'");
     }
     if ($user) {
         if (!($userInfo = posix_getpwnam($user))) {
             throw new ChallengeStoreException("Unknown user: '{$user}'");
         }
     }
     if (isset($userInfo)) {
         (yield \Amp\File\chown($this->docroot . "/.well-known", $userInfo["uid"], -1));
         (yield \Amp\File\chown($this->docroot . "/.well-known/acme-challenge", $userInfo["uid"], -1));
     }
     (yield \Amp\File\put("{$path}/{$token}", $payload));
     if (isset($userInfo)) {
         (yield \Amp\File\chown("{$path}/{$token}", $userInfo["uid"], -1));
     }
     (yield \Amp\File\chmod("{$path}/{$token}", 0644));
 }

 /**
  * @return static
  */
 public static function create($body, DescriptionFactory $descriptionFactory = null, Context $context = null)
 {
     Assert::nullOrString($body);
     if (empty($body)) {
         return new static();
     }
     $matches = [];
     if (!preg_match('/^(' . self::REGEX_VECTOR . ')\\s*(.+)?$/sux', $body, $matches)) {
         return null;
     }
     return new static($matches[1], $descriptionFactory->create(isset($matches[2]) ? $matches[2] : '', $context));
 }

 /**
  * Creates a new option.
  *
  * @param string      $longName    The long option name.
  * @param string|null $shortName   The short option name.
  * @param int         $flags       A bitwise combination of the option flag
  *                                 constants.
  * @param string      $description A human-readable description of the option.
  *
  * @throws InvalidValueException If the default value is invalid.
  */
 public function __construct($longName, $shortName = null, $flags = 0, $description = null)
 {
     $longName = $this->removeDoubleDashPrefix($longName);
     $shortName = $this->removeDashPrefix($shortName);
     Assert::nullOrString($description, 'The option description must be a string or null. Got: %s');
     Assert::nullOrNotEmpty($description, 'The option description must not be empty.');
     $this->assertFlagsValid($flags);
     $this->assertLongNameValid($longName);
     $this->assertShortNameValid($shortName, $flags);
     $this->longName = $longName;
     $this->shortName = $shortName;
     $this->description = $description;
     $this->addDefaultFlags($flags);
     $this->flags = $flags;
 }

 /**
  * @param Certificate $source
  * @param string      $subject
  * @param string      $issuer
  * @param bool        $selfSigned
  * @param \DateTime   $validFrom
  * @param \DateTime   $validTo
  * @param string      $serialNumber
  * @param array       $subjectAlternativeNames
  */
 public function __construct(Certificate $source, $subject, $issuer = null, $selfSigned = true, \DateTime $validFrom = null, \DateTime $validTo = null, $serialNumber = null, array $subjectAlternativeNames = [])
 {
     Assert::stringNotEmpty($subject, __CLASS__ . '::$subject expected a non empty string. Got: %s');
     Assert::nullOrString($issuer, __CLASS__ . '::$issuer expected a string or null. Got: %s');
     Assert::nullOrBoolean($selfSigned, __CLASS__ . '::$selfSigned expected a boolean or null. Got: %s');
     Assert::nullOrString($serialNumber, __CLASS__ . '::$serialNumber expected a string or null. Got: %s');
     Assert::allStringNotEmpty($subjectAlternativeNames, __CLASS__ . '::$subjectAlternativeNames expected a array of non empty string. Got: %s');
     $this->source = $source;
     $this->subject = $subject;
     $this->issuer = $issuer;
     $this->selfSigned = $selfSigned;
     $this->validFrom = $validFrom;
     $this->validTo = $validTo;
     $this->serialNumber = $serialNumber;
     $this->subjectAlternativeNames = $subjectAlternativeNames;
 }

 /**
  * @param string $commonName
  * @param string $countryName
  * @param string $stateOrProvinceName
  * @param string $localityName
  * @param string $organizationName
  * @param string $organizationalUnitName
  * @param string $emailAddress
  * @param array  $subjectAlternativeNames
  */
 public function __construct($commonName, $countryName = null, $stateOrProvinceName = null, $localityName = null, $organizationName = null, $organizationalUnitName = null, $emailAddress = null, array $subjectAlternativeNames = [])
 {
     Assert::stringNotEmpty($commonName, __CLASS__ . '::$commonName expected a non empty string. Got: %s');
     Assert::nullOrString($countryName, __CLASS__ . '::$countryName expected a string. Got: %s');
     Assert::nullOrString($stateOrProvinceName, __CLASS__ . '::$stateOrProvinceName expected a string. Got: %s');
     Assert::nullOrString($localityName, __CLASS__ . '::$localityName expected a string. Got: %s');
     Assert::nullOrString($organizationName, __CLASS__ . '::$organizationName expected a string. Got: %s');
     Assert::nullOrString($organizationalUnitName, __CLASS__ . '::$organizationalUnitName expected a string. Got: %s');
     Assert::nullOrString($emailAddress, __CLASS__ . '::$emailAddress expected a string. Got: %s');
     Assert::allStringNotEmpty($subjectAlternativeNames, __CLASS__ . '::$subjectAlternativeNames expected an array of non empty string. Got: %s');
     $this->commonName = $commonName;
     $this->countryName = $countryName;
     $this->stateOrProvinceName = $stateOrProvinceName;
     $this->localityName = $localityName;
     $this->organizationName = $organizationName;
     $this->organizationalUnitName = $organizationalUnitName;
     $this->emailAddress = $emailAddress;
     $this->subjectAlternativeNames = array_diff(array_unique($subjectAlternativeNames), [$commonName]);
 }

 /**
  * {@inheritdoc}
  */
 public function registerAccount($agreement = null, $email = null)
 {
     Assert::nullOrString($agreement, 'registerAccount::$agreement expected a string or null. Got: %s');
     Assert::nullOrString($email, 'registerAccount::$email expected a string or null. Got: %s');
     $payload = [];
     $payload['resource'] = ResourcesDirectory::NEW_REGISTRATION;
     $payload['agreement'] = $agreement;
     if (is_string($email)) {
         $payload['contact'] = ['mailto:' . $email];
     }
     $response = (array) $this->requestResource('POST', ResourcesDirectory::NEW_REGISTRATION, $payload);
     $links = $this->httpClient->getLastLinks();
     foreach ($links as $link) {
         if ('terms-of-service' === $link['rel']) {
             $agreement = substr($link[0], 1, -1);
             $payload = [];
             $payload['resource'] = ResourcesDirectory::REGISTRATION;
             $payload['agreement'] = $agreement;
             $this->httpClient->signedRequest('POST', $this->httpClient->getLastLocation(), $payload, true);
             break;
         }
     }
     return $response;
 }

 /**
  * @param null|string $subject
  */
 public function setSubject($subject)
 {
     \Webmozart\Assert\Assert::nullOrString($subject);
     $this->subject = $subject;
 }

 /**
  * Returns the file name without the extension from a file path.
  *
  * @param string      $path      The path string.
  * @param string|null $extension If specified, only that extension is cut
  *                               off (may contain leading dot).
  *
  * @return string The file name without extension.
  *
  * @since 1.1 Added method.
  * @since 2.0 Method now fails if $path or $extension have invalid types.
  */
 public static function getFilenameWithoutExtension($path, $extension = null)
 {
     if ('' === $path) {
         return '';
     }
     Assert::string($path, 'The path must be a string. Got: %s');
     Assert::nullOrString($extension, 'The extension must be a string or null. Got: %s');
     if (null !== $extension) {
         // remove extension and trailing dot
         return rtrim(basename($path, $extension), '.');
     }
     return pathinfo($path, PATHINFO_FILENAME);
 }

 /**
  * Creates a new argument.
  *
  * @param string $name         The argument name
  * @param int    $flags        A bitwise combination of the flag constants.
  * @param string $description  A human-readable description of the argument.
  * @param mixed  $defaultValue The default value of the argument (must be
  *                             null for the flag {@link self::REQUIRED}).
  */
 public function __construct($name, $flags = 0, $description = null, $defaultValue = null)
 {
     Assert::string($name, 'The argument name must be a string. Got: %s');
     Assert::notEmpty($name, 'The argument name must not be empty.');
     Assert::startsWithLetter($name, 'The argument name must start with a letter.');
     Assert::regex($name, '~^[a-zA-Z0-9\\-]+$~', 'The argument name must contain letters, digits and hyphens only.');
     Assert::nullOrString($description, 'The argument description must be a string or null. Got: %s');
     Assert::nullOrNotEmpty($description, 'The argument description must not be empty.');
     $this->assertFlagsValid($flags);
     $this->addDefaultFlags($flags);
     $this->name = $name;
     $this->flags = $flags;
     $this->description = $description;
     $this->defaultValue = $this->isMultiValued() ? array() : null;
     if ($this->isOptional() || null !== $defaultValue) {
         $this->setDefaultValue($defaultValue);
     }
 }

 /**
  * Set image
  *
  * @param string $image
  * @return User
  */
 public function setImage($image)
 {
     Assert::nullOrString($image);
     $this->image = $image;
     return $this;
 }