PHP data::isKeyword方法代码示例

 /**
  * Compiles URL addressing current script of current application.
  *
  * @param array|false $parameters set of parameters to pass in query, false
  *        to drop all current parameters (e.g. on creating GET form),
  *        provide special parameter '*' in array to start fresh set of parameters
  * @param mixed $selector first of multiple optional selectors to include
  * @return string URL of addressed script including optional parameters
  */
 public function selfURL($parameters = array(), $selector = null)
 {
     $selectors = func_get_args();
     $selectors = array_slice($selectors, 1);
     if (!count($selectors)) {
         $selectors = application::current()->selectors;
     }
     /*
      * merge current script's input parameters with provided one
      */
     if ($parameters === false) {
         $parameters = array();
     } else {
         // find all non-persistent input parameters of current script
         $currentVolatileParameters = array();
         if (!array_key_exists('*', $parameters)) {
             $get = input::source(input::SOURCE_ACTUAL_GET);
             foreach ($get->listNames() as $name) {
                 if (data::isKeyword($name) && !input::isPersistent($name)) {
                     $currentVolatileParameters[$name] = $get->getValue($name);
                 }
             }
         }
         unset($parameters['*']);
         // merge volatile input with given parameters, but drop all those
         // finally set NULL (to support removal per $parameters)
         $parameters = array_filter(array_merge($currentVolatileParameters, $parameters), function ($item) {
             return $item !== null;
         });
     }
     /*
      * utilize scriptURL() for referring to current script
      */
     array_unshift($selectors, $parameters);
     array_unshift($selectors, $this->script);
     return call_user_func_array(array(&$this, 'scriptURL'), $selectors);
 }

 /**
  * @param integer $itemCount number of records to be paged
  * @param boolean $isVolatile if true, offset/items per page must be always found in actual input
  *                            if false, both are retrieved from cache unless contained in actual input
  *                            if null, offset is expected in actual input while size is not
  * @param string $offsetName name of input selecting offset
  * @param string $sizeName name of input selecting count of items per page
  */
 public function __construct($itemCount, $isVolatile = null, $offsetName = 'skip', $sizeName = 'count')
 {
     if (!ctype_digit(trim($itemCount))) {
         throw new \InvalidArgumentException('invalid item count');
     }
     if (!data::isKeyword($offsetName)) {
         throw new \InvalidArgumentException('invalid offset selector');
     }
     if (!data::isKeyword($sizeName)) {
         throw new \InvalidArgumentException('invalid size selector');
     }
     $this->offsetName = $offsetName;
     $this->sizeName = $sizeName;
     $this->itemCount = $itemCount;
     $this->isVolatile = is_null($isVolatile) ? null : !!$isVolatile;
 }

 /**
  * Iterates over given or configured list of user database providers invoking
  * provided callback on every provider until first callback is returning
  * properly without throwing exception.
  *
  * @param callable $callback callback to invoke per iterated user database provider
  * @param array|string $explicitSource set of provider names to iterate or name of first provider in a sequence to test
  * @return mixed|null result return from callback, null if all callbacks threw exception
  * @throws \RuntimeException on missing valid set of providers to iterate
  * @throws unauthorized_exception if callback is throwing in other case than "user isn't found"
  * @throws \InvalidArgumentException on missing callback
  */
 public static final function findProvider($callback, $explicitSource = null)
 {
     if (!is_callable($callback)) {
         throw new \InvalidArgumentException('invalid callback on finding user provider');
     }
     // get list of sources to look up for requested user
     if (is_array($explicitSource)) {
         $sources = $explicitSource;
     } else {
         $sources = func_get_args();
         array_shift($sources);
     }
     if (!count($sources)) {
         $sources = config::getList('user.sources.enabled');
     }
     if (!count($sources)) {
         throw new \RuntimeException('missing/invalid user sources configuration');
     }
     // traverse list of sources ...
     foreach ($sources as $source) {
         if (trim($source) !== '' && ctype_alnum($source)) {
             // read its configuration
             $definition = config::get('user.sources.setup.' . $source);
             if (is_array($definition)) {
                 // read name of class for managing user source from configuration
                 $class = array_key_exists('class', $definition) ? data::isKeyword($definition['class']) : null;
                 if (!$class) {
                     $class = data::isKeyword($definition['type'] . '_user');
                 }
                 if (txf::import($class)) {
                     try {
                         // create instance of managing class
                         $factory = new \ReflectionClass($class);
                         $user = $factory->newInstance();
                         if ($user instanceof self) {
                             $user->configure($definition);
                             return call_user_func($callback, $user);
                         }
                     } catch (unauthorized_exception $e) {
                         if (!$e->isUserNotFound()) {
                             throw $e;
                         }
                     } catch (\Exception $e) {
                         log::warning('failed to search user source: ' . $e);
                     }
                 }
             }
         }
     }
     return null;
 }

 /**
  * Reads named input variable.
  *
  * Support for $default requires related source manager to be included in
  * queue of enabled input sources.
  *
  * @param string $name name of value to read, must be keyword
  * @param mixed $default value to return by default
  * @param boolean $checkPersistents if true, check persistent sources as well
  * @param mixed $format format definition used to filter values
  * @param boolean $optional set true to suppress exception on missing valid input from any enabled source
  * @return mixed|null available input value, null on missing any
  */
 protected final function readValue($name, $default = null, $checkPersistents = true, $format = null, $optional = false)
 {
     $name = data::isKeyword($name);
     if (!$name) {
         throw new \InvalidArgumentException('invalid input variable name');
     }
     // normalize format once to be used in normalized form
     $format = self::normalizeFormat($format);
     foreach ($this->sources as $source) {
         if ($source['enabled']) {
             if ($checkPersistents || $source['volatile']) {
                 if ($source['manager']->hasValue($name, $default)) {
                     // current source provides value --> validate
                     $value = $source['manager']->getValue($name, $default);
                     if (is_array($value)) {
                         // got an array
                         // --> its elements are validated separately
                         foreach ($value as $key => $element) {
                             if ($this->valueIsValid($element, $format)) {
                                 $value[$key] = $this->convertValue($element, $format);
                             } else {
                                 unset($value[$key]);
                             }
                         }
                         if (count($value)) {
                             // (real subset of) array is valid -> return that
                             return $checkPersistents ? $this->persistValue($name, $value) : $value;
                         }
                     } else {
                         if ($this->valueIsValid($value, $format)) {
                             // value is valid -> return
                             if ($checkPersistents) {
                                 $this->persistValue($name, $value);
                             }
                             return $this->convertValue($value, $format);
                         }
                     }
                 }
             }
         }
     }
     // throw exception if missing any input isn't considered valid input
     // according to provided format definition
     if (!$optional && !$this->valueIsValid(null, $format)) {
         throw new \RuntimeException('invalid input');
     }
     return null;
 }