Note: When control enters apcu_entry() the lock for the cache is acquired exclusively, it is released when + * control leaves apcu_entry(): In effect, this turns the body of generator into a critical section, + * disallowing two processes from executing the same code paths concurrently. + * In addition, it prohibits the concurrent execution of any other APCu functions, + * since they will acquire the same lock. + *
+ * + * @link http://php.net/manual/en/function.apcu-entry.php + * + * @param string $key Identity of cache entry + * @param callable $generator A callable that accepts key as the only argument and returns the value to cache. + *Warning + * The only APCu function that can be called safely by generator is apcu_entry().
+ * @param int $ttl [optional] Time To Live; store var in the cache for ttl seconds. + * After the ttl has passed, the stored variable will be expunged from the cache (on the next request). + * If no ttl is supplied (or if the ttl is 0), the value will persist until it is removed from the cache manually, + * or otherwise fails to exist in the cache (clear, restart, etc.). + * @return mixed Returns the cached value + * @since APCu 5.1.0 + */ +function apcu_entry($key, callable $generator, $ttl = 0){} + +/** + * Retrieves cached information from APCu's data store + * + * @link http://php.net/manual/en/function.apcu-cache-info.php + * + * @param bool $limited If limited is TRUE, the return value will exclude the individual list of cache entries. + * This is useful when trying to optimize calls for statistics gathering. + * @return array|bool Array of cached data (and meta-data) or FALSE on failure + */ +function apcu_cache_info($limited = false){} diff --git a/build/.phan/stubs/memcached.php b/build/.phan/stubs/memcached.php new file mode 100644 index 0000000000..2c8aced175 --- /dev/null +++ b/build/.phan/stubs/memcached.php @@ -0,0 +1,1257 @@ +Enables or disables payload compression. When enabled, + * item values longer than a certain threshold (currently 100 bytes) will be + * compressed during storage and decompressed during retrieval + * transparently. + *Type: boolean, default: TRUE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_COMPRESSION = -1001; + const OPT_COMPRESSION_TYPE = -1004; + + /** + *This can be used to create a "domain" for your item keys. The value + * specified here will be prefixed to each of the keys. It cannot be + * longer than 128 characters and will reduce the + * maximum available key size. The prefix is applied only to the item keys, + * not to the server keys.
+ *Type: string, default: "".
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_PREFIX_KEY = -1002; + + /** + *+ * Specifies the serializer to use for serializing non-scalar values. + * The valid serializers are Memcached::SERIALIZER_PHP + * or Memcached::SERIALIZER_IGBINARY. The latter is + * supported only when memcached is configured with + * --enable-memcached-igbinary option and the + * igbinary extension is loaded. + *
+ *Type: integer, default: Memcached::SERIALIZER_PHP.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_SERIALIZER = -1003; + + /** + *Indicates whether igbinary serializer support is available.
+ *Type: boolean.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HAVE_IGBINARY = 0; + + /** + *Indicates whether JSON serializer support is available.
+ *Type: boolean.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HAVE_JSON = 0; + const HAVE_SESSION = 1; + const HAVE_SASL = 0; + + /** + *Specifies the hashing algorithm used for the item keys. The valid + * values are supplied via Memcached::HASH_* constants. + * Each hash algorithm has its advantages and its disadvantages. Go with the + * default if you don't know or don't care.
+ *Type: integer, default: Memcached::HASH_DEFAULT
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_HASH = 2; + + /** + *The default (Jenkins one-at-a-time) item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_DEFAULT = 0; + + /** + *MD5 item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_MD5 = 1; + + /** + *CRC item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_CRC = 2; + + /** + *FNV1_64 item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_FNV1_64 = 3; + + /** + *FNV1_64A item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_FNV1A_64 = 4; + + /** + *FNV1_32 item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_FNV1_32 = 5; + + /** + *FNV1_32A item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_FNV1A_32 = 6; + + /** + *Hsieh item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_HSIEH = 7; + + /** + *Murmur item key hashing algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const HASH_MURMUR = 8; + + /** + *Specifies the method of distributing item keys to the servers. + * Currently supported methods are modulo and consistent hashing. Consistent + * hashing delivers better distribution and allows servers to be added to + * the cluster with minimal cache losses.
+ *Type: integer, default: Memcached::DISTRIBUTION_MODULA.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_DISTRIBUTION = 9; + + /** + *Modulo-based key distribution algorithm.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const DISTRIBUTION_MODULA = 0; + + /** + *Consistent hashing key distribution algorithm (based on libketama).
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const DISTRIBUTION_CONSISTENT = 1; + const DISTRIBUTION_VIRTUAL_BUCKET = 6; + + /** + *Enables or disables compatibility with libketama-like behavior. When + * enabled, the item key hashing algorithm is set to MD5 and distribution is + * set to be weighted consistent hashing distribution. This is useful + * because other libketama-based clients (Python, Ruby, etc.) with the same + * server configuration will be able to access the keys transparently. + *
+ *+ * It is highly recommended to enable this option if you want to use + * consistent hashing, and it may be enabled by default in future + * releases. + *
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_LIBKETAMA_COMPATIBLE = 16; + const OPT_LIBKETAMA_HASH = 17; + const OPT_TCP_KEEPALIVE = 32; + + /** + *Enables or disables buffered I/O. Enabling buffered I/O causes + * storage commands to "buffer" instead of being sent. Any action that + * retrieves data causes this buffer to be sent to the remote connection. + * Quitting the connection or closing down the connection will also cause + * the buffered data to be pushed to the remote connection.
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_BUFFER_WRITES = 10; + + /** + *Enable the use of the binary protocol. Please note that you cannot + * toggle this option on an open connection.
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_BINARY_PROTOCOL = 18; + + /** + *Enables or disables asynchronous I/O. This is the fastest transport + * available for storage functions.
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_NO_BLOCK = 0; + + /** + *Enables or disables the no-delay feature for connecting sockets (may + * be faster in some environments).
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_TCP_NODELAY = 1; + + /** + *The maximum socket send buffer in bytes.
+ *Type: integer, default: varies by platform/kernel + * configuration.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_SOCKET_SEND_SIZE = 4; + + /** + *The maximum socket receive buffer in bytes.
+ *Type: integer, default: varies by platform/kernel + * configuration.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_SOCKET_RECV_SIZE = 5; + + /** + *In non-blocking mode this set the value of the timeout during socket + * connection, in milliseconds.
+ *Type: integer, default: 1000.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_CONNECT_TIMEOUT = 14; + + /** + *The amount of time, in seconds, to wait until retrying a failed + * connection attempt.
+ *Type: integer, default: 0.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_RETRY_TIMEOUT = 15; + + /** + *Socket sending timeout, in microseconds. In cases where you cannot + * use non-blocking I/O this will allow you to still have timeouts on the + * sending of data.
+ *Type: integer, default: 0.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_SEND_TIMEOUT = 19; + + /** + *Socket reading timeout, in microseconds. In cases where you cannot + * use non-blocking I/O this will allow you to still have timeouts on the + * reading of data.
+ *Type: integer, default: 0.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_RECV_TIMEOUT = 20; + + /** + *Timeout for connection polling, in milliseconds.
+ *Type: integer, default: 1000.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_POLL_TIMEOUT = 8; + + /** + *Enables or disables caching of DNS lookups.
+ *Type: boolean, default: FALSE.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_CACHE_LOOKUPS = 6; + + /** + *Specifies the failure limit for server connection attempts. The + * server will be removed after this many continuous connection + * failures.
+ *Type: integer, default: 0.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const OPT_SERVER_FAILURE_LIMIT = 21; + const OPT_AUTO_EJECT_HOSTS = 28; + const OPT_HASH_WITH_PREFIX_KEY = 25; + const OPT_NOREPLY = 26; + const OPT_SORT_HOSTS = 12; + const OPT_VERIFY_KEY = 13; + const OPT_USE_UDP = 27; + const OPT_NUMBER_OF_REPLICAS = 29; + const OPT_RANDOMIZE_REPLICA_READ = 30; + const OPT_REMOVE_FAILED_SERVERS = 35; + + /** + *The operation was successful.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_SUCCESS = 0; + + /** + *The operation failed in some fashion.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_FAILURE = 1; + + /** + *DNS lookup failed.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_HOST_LOOKUP_FAILURE = 2; + + /** + *Failed to read network data.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_UNKNOWN_READ_FAILURE = 7; + + /** + *Bad command in memcached protocol.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_PROTOCOL_ERROR = 8; + + /** + *Error on the client side.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_CLIENT_ERROR = 9; + + /** + *Error on the server side.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_SERVER_ERROR = 10; + + /** + *Failed to write network data.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_WRITE_FAILURE = 5; + + /** + *Failed to do compare-and-swap: item you are trying to store has been + * modified since you last fetched it.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_DATA_EXISTS = 12; + + /** + *Item was not stored: but not because of an error. This normally + * means that either the condition for an "add" or a "replace" command + * wasn't met, or that the item is in a delete queue.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_NOTSTORED = 14; + + /** + *Item with this key was not found (with "get" operation or "cas" + * operations).
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_NOTFOUND = 16; + + /** + *Partial network data read error.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_PARTIAL_READ = 18; + + /** + *Some errors occurred during multi-get.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_SOME_ERRORS = 19; + + /** + *Server list is empty.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_NO_SERVERS = 20; + + /** + *End of result set.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_END = 21; + + /** + *System error.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_ERRNO = 26; + + /** + *The operation was buffered.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_BUFFERED = 32; + + /** + *The operation timed out.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_TIMEOUT = 31; + + /** + *Bad key.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_BAD_KEY_PROVIDED = 33; + const RES_STORED = 15; + const RES_DELETED = 22; + const RES_STAT = 24; + const RES_ITEM = 25; + const RES_NOT_SUPPORTED = 28; + const RES_FETCH_NOTFINISHED = 30; + const RES_SERVER_MARKED_DEAD = 35; + const RES_UNKNOWN_STAT_KEY = 36; + const RES_INVALID_HOST_PROTOCOL = 34; + const RES_MEMORY_ALLOCATION_FAILURE = 17; + const RES_E2BIG = 37; + const RES_KEY_TOO_BIG = 39; + const RES_SERVER_TEMPORARILY_DISABLED = 47; + const RES_SERVER_MEMORY_ALLOCATION_FAILURE = 48; + const RES_AUTH_PROBLEM = 40; + const RES_AUTH_FAILURE = 41; + const RES_AUTH_CONTINUE = 42; + + + /** + *Failed to create network socket.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_CONNECTION_SOCKET_CREATE_FAILURE = 11; + + /** + *Payload failure: could not compress/decompress or serialize/unserialize the value.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const RES_PAYLOAD_FAILURE = -1001; + + /** + *The default PHP serializer.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const SERIALIZER_PHP = 1; + + /** + *The igbinary serializer. + * Instead of textual representation it stores PHP data structures in a + * compact binary form, resulting in space and time gains.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const SERIALIZER_IGBINARY = 2; + + /** + *The JSON serializer. Requires PHP 5.2.10+.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const SERIALIZER_JSON = 3; + const SERIALIZER_JSON_ARRAY = 4; + const COMPRESSION_FASTLZ = 2; + const COMPRESSION_ZLIB = 1; + + /** + *A flag for Memcached::getMulti and + * Memcached::getMultiByKey to ensure that the keys are + * returned in the same order as they were requested in. Non-existing keys + * get a default value of NULL.
+ * @link http://php.net/manual/en/memcached.constants.php + */ + const GET_PRESERVE_ORDER = 1; + const GET_ERROR_RETURN_VALUE = false; + + + /** + * (PECL memcached >= 0.1.0)+ * The key of the item to retrieve. + *
+ * @param callable $cache_cb [optional]+ * Read-through caching callback or NULL. + *
+ * @param float $cas_token [optional]+ * The variable to store the CAS token in. + *
+ * @return mixed the value stored in the cache or FALSE otherwise. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function get ($key, callable $cache_cb = null, &$cas_token = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key of the item to fetch. + *
+ * @param callable $cache_cb [optional]+ * Read-through caching callback or NULL + *
+ * @param float $cas_token [optional]+ * The variable to store the CAS token in. + *
+ * @return mixed the value stored in the cache or FALSE otherwise. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function getByKey ($server_key, $key, callable $cache_cb = null, &$cas_token = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * Array of keys to retrieve. + *
+ * @param array $cas_tokens [optional]+ * The variable to store the CAS tokens for the found items. + *
+ * @param int $flags [optional]+ * The flags for the get operation. + *
+ * @return mixed the array of found items or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function getMulti (array $keys, array &$cas_tokens = null, $flags = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param array $keys+ * Array of keys to retrieve. + *
+ * @param string $cas_tokens [optional]+ * The variable to store the CAS tokens for the found items. + *
+ * @param int $flags [optional]+ * The flags for the get operation. + *
+ * @return array the array of found items or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function getMultiByKey ($server_key, array $keys, &$cas_tokens = null, $flags = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * Array of keys to request. + *
+ * @param bool $with_cas [optional]+ * Whether to request CAS token values also. + *
+ * @param callable $value_cb [optional]+ * The result callback or NULL. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function getDelayed (array $keys, $with_cas = null, callable $value_cb = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param array $keys+ * Array of keys to request. + *
+ * @param bool $with_cas [optional]+ * Whether to request CAS token values also. + *
+ * @param callable $value_cb [optional]+ * The result callback or NULL. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function getDelayedByKey ($server_key, array $keys, $with_cas = null, callable $value_cb = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function set ($key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function setByKey ($server_key, $key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 2.0.0)+ * The key under which to store the value. + *
+ * @param int $expiration+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function touch ($key, $expiration) {} + + /** + * (PECL memcached >= 2.0.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param int $expiration+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function touchByKey ($server_key, $key, $expiration) {} + + /** + * (PECL memcached >= 0.1.0)+ * An array of key/value pairs to store on the server. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function setMulti (array $items, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param array $items+ * An array of key/value pairs to store on the server. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function setMultiByKey ($server_key, array $items, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * Unique value associated with the existing item. Generated by memcache. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_DATA_EXISTS if the item you are trying + * to store has been modified since you last fetched it. + */ + public function cas ($cas_token, $key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * Unique value associated with the existing item. Generated by memcache. + *
+ * @param string $server_key+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_DATA_EXISTS if the item you are trying + * to store has been modified since you last fetched it. + */ + public function casByKey ($cas_token, $server_key, $key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key already exists. + */ + public function add ($key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key already exists. + */ + public function addByKey ($server_key, $key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key under which to store the value. + *
+ * @param string $value+ * The string to append. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function append ($key, $value) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param string $value+ * The string to append. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function appendByKey ($server_key, $key, $value) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key of the item to prepend the data to. + *
+ * @param string $value+ * The string to prepend. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function prepend ($key, $value) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key of the item to prepend the data to. + *
+ * @param string $value+ * The string to prepend. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function prependByKey ($server_key, $key, $value) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function replace ($key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key under which to store the value. + *
+ * @param mixed $value+ * The value to store. + *
+ * @param int $expiration [optional]+ * The expiration time, defaults to 0. See Expiration Times for more info. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTSTORED if the key does not exist. + */ + public function replaceByKey ($server_key, $key, $value, $expiration = null) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key to be deleted. + *
+ * @param int $time [optional]+ * The amount of time the server will wait to delete the item. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function delete ($key, $time = 0) {} + + /** + * (PECL memcached >= 2.0.0)+ * The keys to be deleted. + *
+ * @param int $time [optional]+ * The amount of time the server will wait to delete the items. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function deleteMulti (array $keys, $time = 0) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key to be deleted. + *
+ * @param int $time [optional]+ * The amount of time the server will wait to delete the item. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function deleteByKey ($server_key, $key, $time = 0) {} + + /** + * (PECL memcached >= 2.0.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param array $keys+ * The keys to be deleted. + *
+ * @param int $time [optional]+ * The amount of time the server will wait to delete the items. + *
+ * @return bool TRUE on success or FALSE on failure. + * The Memcached::getResultCode will return + * Memcached::RES_NOTFOUND if the key does not exist. + */ + public function deleteMultiByKey ($server_key, array $keys, $time = 0) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key of the item to increment. + *
+ * @param int $offset [optional]+ * The amount by which to increment the item's value. + *
+ * @param int $initial_value [optional]+ * The value to set the item to if it doesn't currently exist. + *
+ * @param int $expiry [optional]+ * The expiry time to set on the item. + *
+ * @return int new item's value on success or FALSE on failure. + */ + public function increment ($key, $offset = 1, $initial_value = 0, $expiry = 0) {} + + /** + * (PECL memcached >= 0.1.0)+ * The key of the item to decrement. + *
+ * @param int $offset [optional]+ * The amount by which to decrement the item's value. + *
+ * @param int $initial_value [optional]+ * The value to set the item to if it doesn't currently exist. + *
+ * @param int $expiry [optional]+ * The expiry time to set on the item. + *
+ * @return int item's new value on success or FALSE on failure. + */ + public function decrement ($key, $offset = 1, $initial_value = 0, $expiry = 0) {} + + /** + * (PECL memcached >= 2.0.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key of the item to increment. + *
+ * @param int $offset [optional]+ * The amount by which to increment the item's value. + *
+ * @param int $initial_value [optional]+ * The value to set the item to if it doesn't currently exist. + *
+ * @param int $expiry [optional]+ * The expiry time to set on the item. + *
+ * @return int new item's value on success or FALSE on failure. + */ + public function incrementByKey ($server_key, $key, $offset = 1, $initial_value = 0, $expiry = 0) {} + + /** + * (PECL memcached >= 2.0.0)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @param string $key+ * The key of the item to decrement. + *
+ * @param int $offset [optional]+ * The amount by which to decrement the item's value. + *
+ * @param int $initial_value [optional]+ * The value to set the item to if it doesn't currently exist. + *
+ * @param int $expiry [optional]+ * The expiry time to set on the item. + *
+ * @return int item's new value on success or FALSE on failure. + */ + public function decrementByKey ($server_key, $key, $offset = 1, $initial_value = 0, $expiry = 0) {} + + /** + * (PECL memcached >= 0.1.0)+ * The hostname of the memcache server. If the hostname is invalid, data-related + * operations will set + * Memcached::RES_HOST_LOOKUP_FAILURE result code. + *
+ * @param int $port+ * The port on which memcache is running. Usually, this is + * 11211. + *
+ * @param int $weight [optional]+ * The weight of the server relative to the total weight of all the + * servers in the pool. This controls the probability of the server being + * selected for operations. This is used only with consistent distribution + * option and usually corresponds to the amount of memory available to + * memcache on that server. + *
+ * @return bool TRUE on success or FALSE on failure. + */ + public function addServer ($host, $port, $weight = 0) {} + + /** + * (PECL memcached >= 0.1.1)+ * The key identifying the server to store the value on or retrieve it from. Instead of hashing on the actual key for the item, we hash on the server key when deciding which memcached server to talk to. This allows related items to be grouped together on a single server for efficiency with multi operations. + *
+ * @return array an array containing three keys of host, + * port, and weight on success or FALSE + * on failure. + * Use Memcached::getResultCode if necessary. + */ + public function getServerByKey ($server_key) {} + + /** + * (PECL memcached >= 2.0.0)+ * Numer of seconds to wait before invalidating the items. + *
+ * @return bool TRUE on success or FALSE on failure. + * Use Memcached::getResultCode if necessary. + */ + public function flush ($delay = 0) {} + + /** + * (PECL memcached >= 0.1.0)+ * One of the Memcached::OPT_* constants. + *
+ * @return mixed the value of the requested option, or FALSE on + * error. + */ + public function getOption ($option) {} + + /** + * (PECL memcached >= 0.1.0)+ * An associative array of options where the key is the option to set and + * the value is the new value for the option. + *
+ * @return bool TRUE on success or FALSE on failure. + */ + public function setOptions (array $options) {} + + /** + * (PECL memcached >= 2.0.0)