hphp/runtime/ext/memcached/ext_memcached.php

   1 <?hh
   2 // @generated by docskel.php
   3
   4 /**
   5  * Represents a connection to a set of memcached servers.
   6  */
   7 <<__NativeData("MemcachedData")>>
   8 class Memcached {
   9   /**
  10    * Create a Memcached instance
  11    *
  12    * @param string $persistent_id - By default the Memcached instances are
  13    * destroyed at the end of the request. To create an instance that persists
  14    * between requests, use persistent_id to specify a unique ID for the
  15    * instance. All instances created with the same persistent_id will share the
  16    * same connection.
  17    */
  18   <<__Native>>
  19   public function __construct(?string $persistent_id = null): void;
  20
  21   /**
  22    * Add an item under a new key
  23    *
  24    * @param string $key -
  25    * @param mixed $value -
  26    * @param int $expiration -
  27    *
  28    * @return bool - The Memcached::getResultCode will return
  29    *   Memcached::RES_NOTSTORED if the key already exists.
  30    */
  31   public function add(mixed $key,
  32                       mixed $value,
  33                       mixed $expiration = 0): bool {
  34     return $this->addByKey('', $key, $value, $expiration);
  35   }
  36
  37   /**
  38    * Add an item under a new key on a specific server
  39    *
  40    * @param string $server_key -
  41    * @param string $key -
  42    * @param mixed $value -
  43    * @param int $expiration -
  44    *
  45    * @return bool - The Memcached::getResultCode will return
  46    *   Memcached::RES_NOTSTORED if the key already exists.
  47    */
  48   <<__Native>>
  49   public function addByKey(string $server_key,
  50                            string $key,
  51                            mixed $value,
  52                            int $expiration = 0): bool;
  53
  54   /**
  55    * Add a server to the server pool
  56    *
  57    * @param string $host - The hostname of the memcache server. If the
  58    *   hostname is invalid, data-related operations will set
  59    *   Memcached::RES_HOST_LOOKUP_FAILURE result code.
  60    * @param int $port - The port on which memcache is running. Usually,
  61    *   this is 11211.
  62    * @param int $weight - The weight of the server relative to the total
  63    *   weight of all the servers in the pool. This controls the probability
  64    *   of the server being selected for operations. This is used only with
  65    *   consistent distribution option and usually corresponds to the amount
  66    *   of memory available to memcache on that server.
  67    *
  68    * @return bool -
  69    */
  70   <<__Native>>
  71   public function addServer(string $host,
  72                             int $port,
  73                             int $weight = 0): bool;
  74
  75   /**
  76    * Add multiple servers to the server pool
  77    *
  78    * @param array $servers -
  79    *
  80    * @return bool -
  81    */
  82   public function addServers(array<array<mixed>> $servers): bool {
  83     $servers_vals = array_values($servers);
  84     foreach($servers_vals as $i => $server) {
  85       if (!is_array($server)) {
  86         trigger_error(
  87           sprintf('Server list entry #%d is not an array', $i + 1),
  88           E_WARNING
  89         );
  90         continue;
  91       }
  92       if (count($server) < 1) {
  93         trigger_error(
  94           sprintf('Could not get server host for entry #%d', $i + 1),
  95           E_WARNING
  96         );
  97         continue;
  98       }
  99       if (count($server) < 2) {
 100         trigger_error(
 101           sprintf('Could not get server port for entry #%d', $i + 1),
 102           E_WARNING
 103         );
 104         continue;
 105       }
 106
 107       $host = (string)$server[0];
 108       $port = (int)$server[1];
 109       if (count($server) < 3) {
 110         $weight = 0;
 111       } else {
 112         $weight = (int)$server[2];
 113       }
 114
 115       if (!$this->addServer($host, $port, $weight)) {
 116         trigger_error(
 117           sprintf('Could not add entry #%d to the server list', $i + 1),
 118           E_WARNING
 119         );
 120       }
 121     }
 122     return true;
 123   }
 124
 125   /**
 126    * Append data to an existing item
 127    *
 128    * @param string $key -
 129    * @param string $value - The string to append.
 130    *
 131    * @return bool - The Memcached::getResultCode will return
 132    *   Memcached::RES_NOTSTORED if the key does not exist.
 133    */
 134   public function append(mixed $key,
 135                          mixed $value): bool {
 136     return $this->appendByKey('', $key, $value);
 137   }
 138
 139   /**
 140    * Append data to an existing item on a specific server
 141    *
 142    * @param string $server_key -
 143    * @param string $key -
 144    * @param string $value - The string to append.
 145    *
 146    * @return bool - The Memcached::getResultCode will return
 147    *   Memcached::RES_NOTSTORED if the key does not exist.
 148    */
 149   <<__Native>>
 150   public function appendByKey(string $server_key,
 151                               string $key,
 152                               string $value): bool;
 153
 154   /**
 155    * Compare and swap an item
 156    *
 157    * @param float $cas_token - Unique value associated with the existing
 158    *   item. Generated by memcache.
 159    * @param string $key -
 160    * @param mixed $value -
 161    * @param int $expiration -
 162    *
 163    * @return bool - The Memcached::getResultCode will return
 164    *   Memcached::RES_DATA_EXISTS if the item you are trying to store has
 165    *   been modified since you last fetched it.
 166    */
 167   public function cas(float $cas_token,
 168                       string $key,
 169                       mixed $value,
 170                       int $expiration = 0): bool {
 171     return $this->casByKey($cas_token, '', $key, $value, $expiration);
 172   }
 173
 174   /**
 175    * Compare and swap an item on a specific server
 176    *
 177    * @param float $cas_token - Unique value associated with the existing
 178    *   item. Generated by memcache.
 179    * @param string $server_key -
 180    * @param string $key -
 181    * @param mixed $value -
 182    * @param int $expiration -
 183    *
 184    * @return bool - The Memcached::getResultCode will return
 185    *   Memcached::RES_DATA_EXISTS if the item you are trying to store has
 186    *   been modified since you last fetched it.
 187    */
 188   <<__Native>>
 189   public function casByKey(float $cas_token,
 190                            string $server_key,
 191                            string $key,
 192                            mixed $value,
 193                            int $expiration = 0): bool;
 194
 195   /**
 196    * Decrement numeric item's value
 197    *
 198    * @param string $key - The key of the item to decrement.
 199    * @param int $offset - The amount by which to decrement the item's
 200    *   value.
 201    * @param int $initial_value - The value to set the item to if it
 202    *   doesn't currently exist.
 203    * @param int $expiry - The expiry time to set on the item.
 204    *
 205    * @return int - Returns item's new value on success.
 206    */
 207   public function decrement(string $key,
 208                             int $offset = 1,
 209                             int $initial_value = 0,
 210                             int $expiry = 0): mixed {
 211     return $this->decrementByKey('', $key, $offset, $initial_value, $expiry);
 212   }
 213
 214   /**
 215    * Decrement numeric item's value, stored on a specific server
 216    *
 217    * @param string $server_key -
 218    * @param string $key - The key of the item to decrement.
 219    * @param int $offset - The amount by which to decrement the item's
 220    *   value.
 221    * @param int $initial_value - The value to set the item to if it
 222    *   doesn't currently exist.
 223    * @param int $expiry - The expiry time to set on the item.
 224    *
 225    * @return int - Returns item's new value on success.
 226    */
 227   <<__Native>>
 228   public function decrementByKey(string $server_key,
 229                                  string $key,
 230                                  int $offset = 1,
 231                                  int $initial_value = 0,
 232                                  int $expiry = 0): mixed;
 233
 234   /**
 235    * Delete an item
 236    *
 237    * @param string $key - The key to be deleted.
 238    * @param int $time - The amount of time the server will wait to delete
 239    *   the item.
 240    *
 241    * @return bool - The Memcached::getResultCode will return
 242    *   Memcached::RES_NOTFOUND if the key does not exist.
 243    */
 244   public function delete(mixed $key,
 245                          mixed $time = 0): bool {
 246     return $this->deleteByKey('', $key, $time);
 247   }
 248
 249   /**
 250    * Delete an item from a specific server
 251    *
 252    * @param string $server_key -
 253    * @param string $key - The key to be deleted.
 254    * @param int $time - The amount of time the server will wait to delete
 255    *   the item.
 256    *
 257    * @return bool - The Memcached::getResultCode will return
 258    *   Memcached::RES_NOTFOUND if the key does not exist.
 259    */
 260   <<__Native>>
 261   public function deleteByKey(string $server_key,
 262                               string $key,
 263                               int $time = 0): bool;
 264
 265   /**
 266    * Fetch the next result
 267    *
 268    * @return array - Returns the next result or FALSE otherwise. The
 269    *   Memcached::getResultCode will return Memcached::RES_END if result
 270    *   set is exhausted.
 271    */
 272   <<__Native>>
 273   public function fetch(): mixed;
 274
 275   /**
 276    * Fetch all the remaining results
 277    *
 278    * @return array - Returns the results.
 279    */
 280   <<__Native>>
 281   public function fetchAll(): mixed;
 282
 283   /**
 284    * Invalidate all items in the cache
 285    *
 286    * @param int $delay - Numer of seconds to wait before invalidating the
 287    *   items.
 288    *
 289    * @return bool -
 290    */
 291   <<__Native>>
 292   public function flush(int $delay = 0): bool;
 293
 294   /**
 295    * Retrieve an item
 296    *
 297    * @param string $key - The key of the item to retrieve.
 298    * @param callable $cache_cb - Read-through caching callback or NULL.
 299    * @param float $cas_token - The variable to store the CAS token in.
 300    *
 301    * @return mixed - Returns the value stored in the cache or FALSE
 302    *   otherwise. The Memcached::getResultCode will return
 303    *   Memcached::RES_NOTFOUND if the key does not exist.
 304    */
 305   public function get(mixed $key,
 306                       ?mixed $cache_cb = null,
 307                       ?mixed &$cas_token = null): mixed {
 308     return $this->getByKey('', $key, $cache_cb, $cas_token);
 309   }
 310
 311   /* Memcached::getAllKeys() Gets the keys stored on all the servers
 312    * @return mixed - Returns the keys stored on all the servers on success or
 313    * FALSE on failure.
 314    */
 315   <<__Native>>
 316   public function getAllKeys(): mixed;
 317
 318   /**
 319    * Retrieve an item from a specific server
 320    *
 321    * @param string $server_key -
 322    * @param string $key - The key of the item to fetch.
 323    * @param mixed $cache_cb - Read-through caching callback or NULL
 324    * @param float $cas_token - The variable to store the CAS token in.
 325    *
 326    * @return mixed - Returns the value stored in the cache or FALSE
 327    *   otherwise. The Memcached::getResultCode will return
 328    *   Memcached::RES_NOTFOUND if the key does not exist.
 329    */
 330   <<__Native>>
 331   public function getByKey(string $server_key,
 332                            string $key,
 333                            mixed $cache_cb = null,
 334                            mixed &$cas_token = null): mixed;
 335
 336   /**
 337    * Request multiple items
 338    *
 339    * @param array $keys - Array of keys to request.
 340    * @param bool $with_cas - Whether to request CAS token values also.
 341    * @param callable $value_cb - The result callback or NULL.
 342    *
 343    * @return bool -
 344    */
 345   public function getDelayed(mixed $keys,
 346                              mixed $with_cas = false,
 347                              mixed $value_cb = null): bool {
 348     return $this->getDelayedByKey('', $keys, $with_cas, $value_cb);
 349   }
 350
 351   /**
 352    * Request multiple items from a specific server
 353    *
 354    * @param string $server_key -
 355    * @param array $keys - Array of keys to request.
 356    * @param bool $with_cas - Whether to request CAS token values also.
 357    * @param callable $value_cb - The result callback or NULL.
 358    *
 359    * @return bool -
 360    */
 361   <<__Native>>
 362   public function getDelayedByKey(string $server_key,
 363                                   array $keys,
 364                                   bool $with_cas = false,
 365                                   ?callable $value_cb = null): bool;
 366
 367   /**
 368    * Retrieve multiple items
 369    *
 370    * @param array $keys - Array of keys to retrieve.
 371    * @param array $cas_tokens - The variable to store the CAS tokens for
 372    *   the found items.
 373    * @param int $flags - The flags for the get operation.
 374    *
 375    * @return mixed - Returns the array of found items.
 376    */
 377   public function getMulti(mixed $keys,
 378                            mixed &$cas_tokens = null,
 379                            mixed $flags = 0): mixed {
 380     return $this->getMultiByKey('', $keys, $cas_tokens, $flags);
 381   }
 382
 383   /**
 384    * Retrieve multiple items from a specific server
 385    *
 386    * @param string $server_key -
 387    * @param array $keys - Array of keys to retrieve.
 388    * @param string $cas_tokens - The variable to store the CAS tokens for
 389    *   the found items.
 390    * @param int $flags - The flags for the get operation.
 391    *
 392    * @return array - Returns the array of found items.
 393    */
 394   <<__Native>>
 395   public function getMultiByKey(string $server_key,
 396                                 array $keys,
 397                                 mixed &$cas_tokens = null,
 398                                 int $flags = 0): mixed;
 399
 400   /**
 401    * Retrieve a Memcached option value
 402    *
 403    * @param int $option - One of the Memcached::OPT_* constants.
 404    *
 405    * @return mixed - Returns the value of the requested option, or FALSE
 406    *   on error.
 407    */
 408   <<__Native>>
 409   public function getOption(int $option): mixed;
 410
 411   /**
 412    * Return the result code of the last operation
 413    *
 414    * @return int - Result code of the last Memcached operation.
 415    */
 416   <<__Native>>
 417   public function getResultCode(): int;
 418
 419   /**
 420    * Return the message describing the result of the last operation
 421    *
 422    * @return string - Message describing the result of the last Memcached
 423    *   operation.
 424    */
 425   <<__Native>>
 426   public function getResultMessage(): string;
 427
 428   /**
 429    * Map a key to a server
 430    *
 431    * @param string $server_key -
 432    *
 433    * @return array - Returns an array containing three keys of host,
 434    *   port, and weight on success or FALSE on failure.
 435    */
 436   <<__Native>>
 437   public function getServerByKey(string $server_key): mixed;
 438
 439   /**
 440    * Get the list of the servers in the pool
 441    *
 442    * @return array - The list of all servers in the server pool.
 443    */
 444   <<__Native>>
 445   public function getServerList(): array;
 446
 447   /**
 448    * Clears all server from the list
 449    *
 450    * @return bool - Returns TRUE on success or FALSE on failure.
 451    */
 452   <<__Native>>
 453   public function resetServerList(): bool;
 454
 455   /**
 456    * Get server pool statistics
 457    *
 458    * @return array - Array of server statistics, one entry per server.
 459    */
 460   <<__Native>>
 461   public function getStats(): mixed;
 462
 463   /**
 464    * Get server pool version info
 465    *
 466    * @return array - Array of server versions, one entry per server.
 467    */
 468   <<__Native>>
 469   public function getVersion(): mixed;
 470
 471   /**
 472    * Increment numeric item's value
 473    *
 474    * @param string $key - The key of the item to increment.
 475    * @param int $offset - The amount by which to increment the item's
 476    *   value.
 477    * @param int $initial_value - The value to set the item to if it
 478    *   doesn't currently exist.
 479    * @param int $expiry - The expiry time to set on the item.
 480    *
 481    * @return int - Returns new item's value on success.
 482    */
 483   <<__Native>>
 484   public function increment(string $key,
 485                             int $offset = 1,
 486                             int $initial_value = 0,
 487                             int $expiry = 0): mixed;
 488
 489   /**
 490    * Increment numeric item's value, stored on a specific server
 491    *
 492    * @param string $server_key -
 493    * @param string $key - The key of the item to increment.
 494    * @param int $offset - The amount by which to increment the item's
 495    *   value.
 496    * @param int $initial_value - The value to set the item to if it
 497    *   doesn't currently exist.
 498    * @param int $expiry - The expiry time to set on the item.
 499    *
 500    * @return int - Returns new item's value on success.
 501    */
 502   <<__Native>>
 503   public function incrementByKey(string $server_key,
 504                                  string $key,
 505                                  int $offset = 1,
 506                                  int $initial_value = 0,
 507                                  int $expiry = 0): mixed;
 508
 509   /**
 510    * Prepend data to an existing item
 511    *
 512    * @param string $key - The key of the item to prepend the data to.
 513    * @param string $value - The string to prepend.
 514    *
 515    * @return bool - The Memcached::getResultCode will return
 516    *   Memcached::RES_NOTSTORED if the key does not exist.
 517    */
 518   public function prepend(mixed $key,
 519                           mixed $value): bool {
 520     return $this->prependByKey('', $key, $value);
 521   }
 522
 523   /**
 524    * Prepend data to an existing item on a specific server
 525    *
 526    * @param string $server_key -
 527    * @param string $key - The key of the item to prepend the data to.
 528    * @param string $value - The string to prepend.
 529    *
 530    * @return bool - The Memcached::getResultCode will return
 531    *   Memcached::RES_NOTSTORED if the key does not exist.
 532    */
 533   <<__Native>>
 534   public function prependByKey(string $server_key,
 535                                string $key,
 536                                string $value): bool;
 537
 538   /**
 539    * Replace the item under an existing key
 540    *
 541    * @param string $key -
 542    * @param mixed $value -
 543    * @param int $expiration -
 544    *
 545    * @return bool - The Memcached::getResultCode will return
 546    *   Memcached::RES_NOTSTORED if the key does not exist.
 547    */
 548   public function replace(mixed $key,
 549                           mixed $value,
 550                           mixed $expiration = 0): bool {
 551     return $this->replaceByKey('', $key, $value, $expiration);
 552   }
 553
 554   /**
 555    * Replace the item under an existing key on a specific server
 556    *
 557    * @param string $server_key -
 558    * @param string $key -
 559    * @param mixed $value -
 560    * @param int $expiration -
 561    *
 562    * @return bool - The Memcached::getResultCode will return
 563    *   Memcached::RES_NOTSTORED if the key does not exist.
 564    */
 565   <<__Native>>
 566   public function replaceByKey(string $server_key,
 567                                string $key,
 568                                mixed $value,
 569                                int $expiration = 0): bool;
 570
 571   /**
 572    * Store an item
 573    *
 574    * @param string $key -
 575    * @param mixed $value -
 576    * @param int $expiration -
 577    *
 578    * @return bool -
 579    */
 580   public function set(mixed $key,
 581                       mixed $value,
 582                       mixed $expiration = 0): bool {
 583     return $this->setByKey('', $key, $value, $expiration);
 584   }
 585
 586   /**
 587    * Store an item on a specific server
 588    *
 589    * @param string $server_key -
 590    * @param string $key -
 591    * @param mixed $value -
 592    * @param int $expiration -
 593    *
 594    * @return bool -
 595    */
 596   <<__Native>>
 597   public function setByKey(string $server_key,
 598                            string $key,
 599                            mixed $value,
 600                            int $expiration = 0): bool;
 601
 602   /**
 603    * Store multiple items
 604    *
 605    * @param array $items -
 606    * @param int $expiration -
 607    *
 608    * @return bool -
 609    */
 610   public function setMulti(array<string, mixed> $items,
 611                            int $expiration = 0): bool {
 612     return $this->setMultiByKey('', $items, $expiration);
 613   }
 614
 615   /**
 616    * Store multiple items on a specific server
 617    *
 618    * @param string $server_key -
 619    * @param array $items -
 620    * @param int $expiration -
 621    *
 622    * @return bool -
 623    */
 624   public function setMultiByKey(string $server_key,
 625                                 array<string, mixed> $items,
 626                                 int $expiration = 0): bool {
 627     foreach($items as $key => $value) {
 628       if (!is_string($key)) {
 629         continue;
 630       }
 631       if (!$this->setByKey($server_key, $key, $value, $expiration)) {
 632         return false;
 633       }
 634     }
 635     return true;
 636   }
 637
 638   /**
 639    * Set a Memcached option
 640    *
 641    * @param int $option -
 642    * @param mixed $value -
 643    *
 644    * @return bool -
 645    */
 646   <<__Native>>
 647   public function setOption(int $option,
 648                             mixed $value): bool;
 649
 650   /**
 651    * Set Memcached options
 652    *
 653    * @param array $options -
 654    *
 655    * @return bool -
 656    */
 657   public function setOptions(array<int, mixed> $options): bool {
 658     foreach($options as $option => $value) {
 659       if (!$this->setOption($option, $value)) {
 660         return false;
 661       }
 662     }
 663     return true;
 664   }
 665
 666 }
 667
 668 class MemcachedException {
 669 }