PHP Assert::nullOrStringNotEmpty方法代码示例

 /**
  * Creates a binding type descriptor.
  *
  * @param BindingType $type                  The described type.
  * @param string|null $description           A human-readable description of
  *                                           the type.
  * @param string[]    $parameterDescriptions Human-readable descriptions
  *                                           indexed by the type's parameter
  *                                           names.
  *
  * @throws NoSuchParameterException If a description is passed for an unset
  *                                  parameter.
  */
 public function __construct(BindingType $type, $description = null, array $parameterDescriptions = array())
 {
     Assert::nullOrStringNotEmpty($description, 'The description must be a non-empty string or null. Got: %s');
     Assert::allStringNotEmpty($parameterDescriptions, 'The parameter description must be a non-empty string. Got: %s');
     $this->type = $type;
     $this->description = $description;
     foreach ($parameterDescriptions as $parameterName => $parameterDescription) {
         if (!$type->hasParameter($parameterName)) {
             throw NoSuchParameterException::forParameterName($parameterName, $type->getName());
         }
         $this->parameterDescriptions[$parameterName] = $parameterDescription;
     }
 }

 /**
  * Creates a new installer descriptor.
  *
  * @param string               $name        The installer name.
  * @param string               $className   The fully-qualified class name
  *                                          of the installer.
  * @param string|null          $description The description of the installer.
  * @param InstallerParameter[] $parameters  The installer parameters.
  */
 public function __construct($name, $className, $description = null, array $parameters = array())
 {
     Assert::stringNotEmpty($name, 'The installer name must be a non-empty string. Got: %s');
     Assert::stringNotEmpty($className, 'The installer class must be a non-empty string. Got: %s');
     Assert::nullOrStringNotEmpty($description, 'The installer description must be a non-empty string or null. Got: %s');
     Assert::allIsInstanceOf($parameters, __NAMESPACE__ . '\\InstallerParameter');
     $this->name = $name;
     $this->className = $className;
     $this->description = $description;
     foreach ($parameters as $parameter) {
         $this->parameters[$parameter->getName()] = $parameter;
     }
 }

 /**
  * Creates the import statement.
  *
  * @param string      $className The fully-qualified imported class name.
  * @param string|null $alias     If not `null`, the class will be imported
  *                               with the given alias.
  */
 public function __construct($className, $alias = null)
 {
     Assert::stringNotEmpty($className, 'The imported class name must be a non-empty string. Got: %s');
     Assert::nullOrStringNotEmpty($className, 'The import alias must be a non-empty string or null. Got: %s');
     $pos = strrpos($className, '\\');
     if (false === $pos) {
         $this->namespaceName = '';
         $this->shortClassName = $className;
     } else {
         $this->namespaceName = substr($className, 0, $pos);
         $this->shortClassName = substr($className, $pos + 1);
     }
     $this->alias = $alias;
 }

 /**
  * {@inheritdoc}
  */
 public function refreshFactoryClass($path = null, $className = null)
 {
     Assert::nullOrStringNotEmpty($path, 'The path to the generated factory file must be a non-empty string or null. Got: %s');
     Assert::nullOrStringNotEmpty($className, 'The class name of the generated factory must be a non-empty string or null. Got: %s');
     $path = Path::makeAbsolute($path ?: $this->config->get(Config::FACTORY_OUT_FILE), $this->rootDir);
     $className = $className ?: $this->config->get(Config::FACTORY_OUT_CLASS);
     if (!$this->config->get(Config::FACTORY_AUTO_GENERATE)) {
         return;
     }
     if (!file_exists($path)) {
         $this->generateFactoryClass($path, $className);
         return;
     }
     $rootModuleFile = $this->context->getRootModuleFile()->getPath();
     if (!file_exists($rootModuleFile)) {
         return;
     }
     // Regenerate file if the configuration has changed and
     // auto-generation is enabled
     clearstatcache(true, $rootModuleFile);
     $lastConfigChange = filemtime($rootModuleFile);
     $configFile = $this->context->getConfigFile() ? $this->context->getConfigFile()->getPath() : '';
     if (file_exists($configFile)) {
         clearstatcache(true, $configFile);
         $lastConfigChange = max(filemtime($configFile), $lastConfigChange);
     }
     clearstatcache(true, $path);
     $lastFactoryUpdate = filemtime($path);
     if ($lastConfigChange > $lastFactoryUpdate) {
         $this->generateFactoryClass($path, $className);
     }
 }