PHP static::key方法代码示例

 /**
  * Get the key for hashing
  * 
  * @return string
  */
 private static function getKey()
 {
     if (static::$key === null) {
         static::$key = Application::getConfig('application', 'key');
     }
     return static::$key;
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     // make completely random key/bucket based on time
     static::$key = md5(rand(0, 99) . time());
     static::$bucket = md5(rand(0, 99) . time());
 }

 /**
  * Get the Datastore key, as stored in the datastore configuration file.
  *
  * @return   string           Returns the datastore key
  */
 public static function key()
 {
     if (static::$key === false) {
         static::$key = Config::get('datastore.key');
     }
     return static::$key;
 }

 protected static function getKey()
 {
     if (!static::$key) {
         static::$key = static::$cachePrefix . '_' . static::getClientIp();
     }
     return static::$key;
 }

 public static function init()
 {
     if (!ctype_xdigit(Config::get('encryption.cipher'))) {
         throw new Exception('Change your cipher code in app/config/encryption.php file!');
     }
     static::$iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);
     static::$key = pack('H*', Config::get('encryption.cipher'));
 }

 /**
  * Magic method called when a class is first encountered by the Autoloader,
  * providing static initialization.
  *
  * @return   void             No value is returned
  */
 public static function __initialize()
 {
     if ((static::$key = Config::get('crypt.key')) == '') {
         throw new \Exception('The Crypt class cannot be used without providing a shared key. Please specify on in your crypt configuration file');
     }
     static::$defaultDriver = Config::get('crypt.driver', 'xcrypt');
     static::$hasher = Config::get('crypt.hasher', 'sha1');
     static::$key = md5(static::$key);
 }

 /**
  * Constructor.
  *
  * @access  protected
  */
 protected function __construct()
 {
     // Set current time
     static::$now = time();
     // Cache key allows us to invalidate all cache on configuration changes.
     static::$key = (Config::get('system.cache.prefix') ? Config::get('system.cache.prefix') : 'fansoro') . '-' . md5(ROOT_DIR . Fansoro::VERSION);
     // Get Cache Driver
     static::$driver = static::getCacheDriver();
     // Set the cache namespace to our unique key
     static::$driver->setNamespace(static::$key);
 }

 /**
  * Sets up the fixture.
  *
  * This method is called before a test is executed.
  *
  * @return  void
  *
  * @since   1.0
  */
 protected function setUp()
 {
     if (empty(static::$object)) {
         $this->markTestSkipped('There is no caching engine.');
     }
     $key = md5(date(DATE_RFC2822));
     $value = 'Test value';
     static::$key = $key;
     static::$value = $value;
     static::$sessionName = 'SessionName';
     static::$sessionPath = 'SessionPath';
     static::$className = get_class(static::$object);
     parent::setUp();
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     // make completely random key based on time
     static::$key = md5(rand(0, 99) . time());
     try {
         // Skip this suite if the "hlls" bucket type is not present
         $command = (new Command\Builder\FetchBucketProperties(static::$riak))->buildBucket('test', static::HLL_BUCKET_TYPE)->build();
         $response = $command->execute();
         if (!$response->isSuccess() || $response->getCode() != 200) {
             throw new \PHPUnit_Framework_SkippedTestSuiteError("hlls bucket type is not enabled and activated, skipping");
         }
     } catch (\Exception $ex) {
         throw new \PHPUnit_Framework_SkippedTestSuiteError("hlls bucket type is not enabled and activated, skipping");
     }
 }

 public static function setUpBeforeClass()
 {
     // make completely random key based on time
     static::$key = md5(rand(0, 99) . time());
 }

 /**
  * Update a model instance in the database.
  *
  * @param  mixed  $id
  * @param  array  $attributes
  * @return int
  */
 public static function update($id, $attributes)
 {
     $model = new static(array(), true);
     if (static::$timestamps) {
         $attributes['updated_at'] = new \DateTime();
     }
     return $model->query()->where($model->key(), '=', $id)->update($attributes);
 }

 /**
  * setKey modifie la clé de cryptage
  *
  * @param string $key
  */
 public static function setkey($key)
 {
     static::$key = $key;
 }

 public static function tearDownAfterClass()
 {
     static::$response_data = null;
     static::$key = null;
 }

 /**
  * Retrieve key => value pairs using `id` for keys and the given attribute
  * for values.
  * 
  * @param string $attribute
  * @param array  $filter    [optional]
  * @param array  $order     [optional]
  * @param int    $limit     [optional]
  * @param int    $offset    [optional]
  * @return array
  */
 public static function listing($attribute, $filter = array(), $order = array(), $limit = null, $offset = 0)
 {
     $instance = new static();
     $storage = $instance->storage();
     $data = $storage->listing($instance->table(), array($instance->key(), $attribute), $filter, $order, $limit, $offset);
     return static::prepareListing($data, $attribute);
 }

 public static function tearDownAfterClass()
 {
     static::$key = null;
 }