PHP Assert::isBoolean方法代码示例

 function __construct($title = null, $block = false)
 {
     Assert::isScalarOrNull($title);
     Assert::isBoolean($block);
     $this->title = $title;
     $this->block = $block;
 }

 /**
  * @return DoctypeDeclaration
  **/
 public function setPublic($isPublic)
 {
     Assert::isBoolean($isPublic);
     $this->public = $isPublic;
     $this->inline = false;
     return $this;
 }

 /**
  * @param boolean whether to use include path or not
  * @param boolean whether to allow pre-scanning technique or not. PreScan is important for 
  * huge and distributed class locations
  */
 function __construct($useIncludePath = true, $allowPreScan = false)
 {
     Assert::isBoolean($allowPreScan);
     $this->allowPreScan = $allowPreScan;
     parent::__construct($useIncludePath);
     $this->setExtension(PHOEBIUS_TYPE_EXTENSION);
 }

 function getParameterList($requiredOnly = true)
 {
     Assert::isBoolean($requiredOnly);
     if ($requiredOnly && $this->isOptional) {
         return array();
     }
     return array($this->name);
 }

 public function __construct(Identifiable $parent, GenericDAO $dao, $lazy = true)
 {
     Assert::isBoolean($lazy);
     $this->parent = $parent;
     $this->lazy = $lazy;
     $this->dao = $dao;
     Assert::isInstance($dao->getObjectName(), 'Identifiable');
     $this->comparator = SerializedObjectComparator::me();
 }

 /**
  * Performs validation against custom parameters (convention, and even processor).
  * Please consider, how methods with the long list of arguments are formatted.
  * @param $target object to validate
  * @param $somethingElse boolean something else argument
  * @return CodingStyleValidator itself
  */
 function validateAgainstCustom(IConvention $convention, CodingStyleProcessor $processor, $target, $somethingElse = true)
 {
     // do not forget to check custom arguments against their expected type
     Assert::isTrue(is_object($target));
     Assert::isBoolean($somethingElse);
     $this->convention = $convention;
     $this->processor = $processor->setTarget($target)->setSomethingElse($somethingElse);
     $this->runValidation();
     return $this;
 }

 /**
  * @param string $filepath path to the file that should be presented in response
  * @param string $filename optional name of the file to be specified in the response
  * @param string $contentType optional content type of the file to be specified in the response
  * @param boolean $unlinkOnFinish whether to remove the file when response is finished
  */
 function __construct($filepath, $filename = null, $contentType = null, $unlinkOnFinish = false)
 {
     Assert::isTrue(is_file($filepath));
     Assert::isScalarOrNull($filename);
     Assert::isScalarOrNull($contentType);
     Assert::isBoolean($unlinkOnFinish);
     $this->filepath = $filepath;
     $this->filename = $filename ? $filename : basename($filepath);
     $this->contentType = $contentType;
     $this->unlinkOnFileFlush = $unlinkOnFinish;
 }

 /**
  * @param string $name name of the property
  * @param array list of database field names
  * @param OrmPropertyType property type
  * @param false property visibility
  * @param boolean whether the property unique or not
  */
 function __construct($name, array $fields, OrmPropertyType $type, OrmPropertyVisibility $visibility, AssociationMultiplicity $multiplicity, $isUnique = false, $isIdentifier = false)
 {
     Assert::isScalar($name);
     Assert::isBoolean($isUnique);
     Assert::isBoolean($isIdentifier);
     $this->name = $name;
     Assert::isTrue(sizeof($fields) == $type->getColumnCount(), 'wrong DB field count');
     $this->fields = $fields;
     $this->type = $type;
     $this->visibility = $visibility;
     $this->multiplicity = $multiplicity;
     $this->isUnique = $isUnique;
     $this->isIdentifier = $isIdentifier;
 }

 /**
  * @return RedirectView
  **/
 public function setBuildArrays($really)
 {
     Assert::isBoolean($really);
     $this->buildArrays = $really;
     return $this;
 }

 /**
  * Resolves the file path containing the requested class. Firstly, searches withing the cache
  * provided by {@link InternalSegmentCache}, then invokes the path scanner and comparer
  * provided by a descendant class
  * @param string $classname
  * @param boolean $checkIfExists
  * @return string|null returns the absolute path to the file containing the requested class
  * 	or NULL if such file not found
  */
 private function resolveClassPath($classname, $checkIfExists, $useCacheOnly = false)
 {
     Assert::isScalar($classname);
     Assert::isBoolean($checkIfExists);
     if (isset($this->foundClasspaths[$classname])) {
         return $this->foundClasspaths[$classname];
     }
     $classpath = null;
     if ($this->isCached($classname)) {
         $classpath = $this->getCached($classname);
         if ($checkIfExists && $classpath) {
             if (!file_exists($classpath)) {
                 $this->uncache($classname);
                 $classpath = null;
             }
         }
     }
     if (!$classpath && !$useCacheOnly) {
         $classpath = $this->scanClassPaths($classname);
         if ($classpath) {
             $this->cache($classname, $classpath);
         }
     }
     if ($classpath) {
         $this->foundClasspaths[$classname] = $classpath;
     }
     return $classpath;
 }

 function getSqlBooleanValue($value)
 {
     Assert::isBoolean($value);
     return $value ? 't' : 'f';
 }

 public function setOverlapped($overlapped = true)
 {
     Assert::isBoolean($overlapped);
     $this->overlapped = $overlapped === true;
     return $this;
 }

 /**
  * @param $really boolean
  * @return CurlHttpClient
  **/
 public function setNoBody($really)
 {
     Assert::isBoolean($really);
     $this->noBody = $really;
     return $this;
 }

 private function invokeResolvers($classname, $useCacheOnly)
 {
     Assert::isBoolean($useCacheOnly);
     foreach ($this->resolvers as $resolver) {
         $result = $resolver->loadClassFile($classname, $useCacheOnly);
         if ($result && ($classpath = $resolver->getClassPath($classname, true))) {
             $this->classPaths[] = $classpath;
             break;
         }
     }
     return TypeUtils::isDefined($classname);
 }

 /**
  * @return HtmlTokenizer
  **/
 public function lowercaseTags($isLowercaseTags)
 {
     Assert::isBoolean($isLowercaseTags);
     $this->lowercaseTags = $isLowercaseTags;
     return $this;
 }