HashBagOStuff.php

Go to the documentation of this file.

<?php
class HashBagOStuff extends MediumSpecificBagOStuff {
    protected $bag = [];
    protected $maxCacheKeys;
 
    private $token;
 
    private static $casCounter = 0;
 
    public const KEY_VAL = 0;
    public const KEY_EXP = 1;
    public const KEY_CAS = 2;
 
    public function __construct( $params = [] ) {
        $params['segmentationSize'] = $params['segmentationSize'] ?? INF;
        parent::__construct( $params );
 
        $this->token = microtime( true ) . ':' . mt_rand();
        $this->maxCacheKeys = $params['maxKeys'] ?? INF;
        if ( $this->maxCacheKeys <= 0 ) {
            throw new InvalidArgumentException( '$maxKeys parameter must be above zero' );
        }
 
        $this->attrMap[self::ATTR_DURABILITY] = self::QOS_DURABILITY_SCRIPT;
        $this->attrMap[self::ATTR_LOCALITY] = self::QOS_LOCALITY_PROC;
    }
 
    protected function doGet( $key, $flags = 0, &$casToken = null ) {
        $getToken = ( $casToken === self::PASS_BY_REF );
        $casToken = null;
 
        if ( !$this->hasKey( $key ) || $this->expire( $key ) ) {
            return false;
        }
 
        // Refresh key position for maxCacheKeys eviction
        $temp = $this->bag[$key];
        unset( $this->bag[$key] );
        $this->bag[$key] = $temp;
 
        if ( $getToken ) {
            $casToken = $this->bag[$key][self::KEY_CAS];
        }
 
        return $this->bag[$key][self::KEY_VAL];
    }
 
    protected function doSet( $key, $value, $exptime = 0, $flags = 0 ) {
        // Refresh key position for maxCacheKeys eviction
        unset( $this->bag[$key] );
        $this->bag[$key] = [
            self::KEY_VAL => $value,
            self::KEY_EXP => $this->getExpirationAsTimestamp( $exptime ),
            self::KEY_CAS => $this->token . ':' . ++self::$casCounter
        ];
 
        if ( count( $this->bag ) > $this->maxCacheKeys ) {
            reset( $this->bag );
            $evictKey = key( $this->bag );
            unset( $this->bag[$evictKey] );
        }
 
        return true;
    }
 
    protected function doAdd( $key, $value, $exptime = 0, $flags = 0 ) {
        if ( $this->hasKey( $key ) && !$this->expire( $key ) ) {
            return false; // key already set
        }
 
        return $this->doSet( $key, $value, $exptime, $flags );
    }
 
    protected function doDelete( $key, $flags = 0 ) {
        unset( $this->bag[$key] );
 
        return true;
    }
 
    public function incr( $key, $value = 1, $flags = 0 ) {
        $n = $this->get( $key );
        if ( $this->isInteger( $n ) ) {
            $n = max( $n + (int)$value, 0 );
            $this->bag[$key][self::KEY_VAL] = $n;
 
            return $n;
        }
 
        return false;
    }
 
    public function decr( $key, $value = 1, $flags = 0 ) {
        return $this->incr( $key, -$value, $flags );
    }
 
    public function clear() {
        $this->bag = [];
    }
 
    protected function expire( $key ) {
        $et = $this->bag[$key][self::KEY_EXP];
        if ( $et == self::TTL_INDEFINITE || $et > $this->getCurrentTime() ) {
            return false;
        }
 
        $this->doDelete( $key );
 
        return true;
    }
 
    public function setNewPreparedValues( array $valueByKey ) {
        // Do not bother with serialization as this class does not serialize values
        $sizes = [];
        foreach ( $valueByKey as $value ) {
            $sizes[] = $this->guessSerialValueSize( $value );
        }
 
        return $sizes;
    }
 
    public function hasKey( $key ) {
        return isset( $this->bag[$key] );
    }
}