git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/memcached.hpp

   1 /*
   2  * Summary: C++ interface for memcached server
   3  *
   4  * Copy: See Copyright for the status of this software.
   5  *
   6  * Authors: Padraig O'Sullivan <osullivan.padraig@gmail.com>
   7  *          Patrick Galbraith <patg@patg.net>
   8  */
   9
  10 /**
  11  * @file memcached.hpp
  12  * @brief Libmemcached C++ interface
  13  */
  14
  15 #pragma once
  16
  17 #include <libmemcached/memcached.h>
  18 #include <libmemcached/exception.hpp>
  19
  20 #include <string.h>
  21
  22 #include <sstream>
  23 #include <string>
  24 #include <vector>
  25 #include <map>
  26
  27 namespace memcache
  28 {
  29
  30 /**
  31  * This is the core memcached library (if later, other objects
  32  * are needed, they will be created from this class).
  33  */
  34 class Memcache
  35 {
  36 public:
  37
  38   Memcache()
  39   {
  40     memc= memcached("", 0);
  41   }
  42
  43   Memcache(const std::string &config)
  44   {
  45     memc= memcached(config.c_str(), config.size());
  46   }
  47
  48   Memcache(const std::string &hostname, in_port_t port)
  49   {
  50     memc= memcached("", 0);
  51     if (memc)
  52       memcached_server_add(memc, hostname.c_str(), port);
  53   }
  54
  55   Memcache(memcached_st *clone)
  56   {
  57     memc= memcached_clone(NULL, clone);
  58   }
  59
  60   Memcache(const Memcache &rhs)
  61   {
  62     memc= memcached_clone(NULL, rhs.getImpl());
  63   }
  64
  65   Memcache &operator=(const Memcache &rhs)
  66   {
  67     if (this != &rhs)
  68     {
  69       memcached_free(memc);
  70       memc= memcached_clone(NULL, rhs.getImpl());
  71     }
  72
  73     return *this;
  74   }
  75
  76   ~Memcache()
  77   {
  78     memcached_free(memc);
  79   }
  80
  81   /**
  82    * Get the internal memcached_st *
  83    */
  84   const memcached_st *getImpl() const
  85   {
  86     return memc;
  87   }
  88
  89   /**
  90    * Return an error string for the given return structure.
  91    *
  92    * @param[in] rc a memcached_return_t structure
  93    * @return error string corresponding to given return code in the library.
  94    */
  95   const std::string getError(memcached_return_t rc) const
  96   {
  97     /* first parameter to strerror is unused */
  98     return memcached_strerror(NULL, rc);
  99   }
 100
 101
 102   bool setBehavior(memcached_behavior_t flag, uint64_t data)
 103   {
 104     return (memcached_success(memcached_behavior_set(memc, flag, data)));
 105   }
 106
 107   uint64_t getBehavior(memcached_behavior_t flag)
 108   {
 109     return memcached_behavior_get(memc, flag);
 110   }
 111
 112   /**
 113    * Configure the memcache object
 114    *
 115    * @param[in] in_config configuration
 116    * @return true on success; false otherwise
 117    */
 118   bool configure(const std::string &configuration)
 119   {
 120     memcached_st *new_memc= memcached(configuration.c_str(), configuration.size());
 121
 122     if (new_memc)
 123     {
 124       memcached_free(memc);
 125       memc= new_memc;
 126
 127       return true;
 128     }
 129
 130     return false;
 131   }
 132
 133   /**
 134    * Add a server to the list of memcached servers to use.
 135    *
 136    * @param[in] server_name name of the server to add
 137    * @param[in] port port number of server to add
 138    * @return true on success; false otherwise
 139    */
 140   bool addServer(const std::string &server_name, in_port_t port)
 141   {
 142     return memcached_success(memcached_server_add(memc, server_name.c_str(), port));
 143   }
 144
 145   /**
 146    * Remove a server from the list of memcached servers to use.
 147    *
 148    * @param[in] server_name name of the server to remove
 149    * @param[in] port port number of server to remove
 150    * @return true on success; false otherwise
 151    */
 152   bool removeServer(const std::string &server_name, in_port_t port)
 153   {
 154     std::string tmp_str;
 155     std::ostringstream strstm;
 156     tmp_str.append(",");
 157     tmp_str.append(server_name);
 158     tmp_str.append(":");
 159     strstm << port;
 160     tmp_str.append(strstm.str());
 161
 162     //memcached_return_t rc= memcached_server_remove(server);
 163
 164     return false;
 165   }
 166
 167   /**
 168    * Fetches an individual value from the server. mget() must always
 169    * be called before using this method.
 170    *
 171    * @param[in] key key of object to fetch
 172    * @param[out] ret_val store returned object in this vector
 173    * @return a memcached return structure
 174    */
 175   memcached_return_t fetch(std::string &key,
 176                            std::vector<char> &ret_val,
 177                            uint32_t &flags,
 178                            uint64_t &cas_value)
 179   {
 180     memcached_return_t rc;
 181
 182     memcached_result_st *result;
 183     if ((result= memcached_fetch_result(memc, NULL, &rc)))
 184     {
 185       // Key
 186       key.assign(memcached_result_key_value(result), memcached_result_key_length(result));
 187
 188       // Actual value, null terminated
 189       ret_val.reserve(memcached_result_length(result) +1);
 190       ret_val.assign(memcached_result_value(result),
 191                      memcached_result_value(result) +memcached_result_length(result));
 192
 193       // Misc
 194       flags= memcached_result_flags(result);
 195       cas_value= memcached_result_cas(result);
 196     }
 197     memcached_result_free(result);
 198
 199     return rc;
 200   }
 201
 202   memcached_return_t fetch(std::string &key,
 203                            std::vector<char> &ret_val)
 204   {
 205     uint32_t flags= 0;
 206     uint64_t cas_value= 0;
 207
 208     return fetch(key, ret_val, flags, cas_value);
 209   }
 210
 211   /**
 212    * Fetches an individual value from the server.
 213    *
 214    * @param[in] key key of object whose value to get
 215    * @param[out] ret_val object that is retrieved is stored in
 216    *                     this vector
 217    * @return true on success; false otherwise
 218    */
 219   bool get(const std::string &key, std::vector<char> &ret_val)
 220   {
 221     uint32_t flags= 0;
 222     memcached_return_t rc;
 223     size_t value_length= 0;
 224
 225     char *value= memcached_get(memc, key.c_str(), key.length(),
 226                                &value_length, &flags, &rc);
 227     if (value != NULL && ret_val.empty())
 228     {
 229       ret_val.reserve(value_length);
 230       ret_val.assign(value, value + value_length);
 231       free(value);
 232       return true;
 233     }
 234
 235     return false;
 236   }
 237
 238   /**
 239    * Fetches an individual from a server which is specified by
 240    * the master_key parameter that is used for determining which
 241    * server an object was stored in if key partitioning was
 242    * used for storage.
 243    *
 244    * @param[in] master_key key that specifies server object is stored on
 245    * @param[in] key key of object whose value to get
 246    * @param[out] ret_val object that is retrieved is stored in
 247    *                     this vector
 248    * @return true on success; false otherwise
 249    */
 250   bool getByKey(const std::string &master_key,
 251                 const std::string &key,
 252                 std::vector<char> &ret_val)
 253   {
 254     uint32_t flags= 0;
 255     memcached_return_t rc;
 256     size_t value_length= 0;
 257
 258     char *value= memcached_get_by_key(memc,
 259                                       master_key.c_str(), master_key.length(),
 260                                       key.c_str(), key.length(),
 261                                       &value_length, &flags, &rc);
 262     if (value)
 263     {
 264       ret_val.reserve(value_length);
 265       ret_val.assign(value, value + value_length);
 266       free(value);
 267       return true;
 268     }
 269     return false;
 270   }
 271
 272   /**
 273    * Selects multiple keys at once. This method always
 274    * works asynchronously.
 275    *
 276    * @param[in] keys vector of keys to select
 277    * @return true if all keys are found
 278    */
 279   bool mget(std::vector<std::string> &keys)
 280   {
 281     std::vector<const char *> real_keys;
 282     std::vector<size_t> key_len;
 283     /*
 284      * Construct an array which will contain the length
 285      * of each of the strings in the input vector. Also, to
 286      * interface with the memcached C API, we need to convert
 287      * the vector of std::string's to a vector of char *.
 288      */
 289     real_keys.reserve(keys.size());
 290     key_len.reserve(keys.size());
 291
 292     std::vector<std::string>::iterator it= keys.begin();
 293
 294     while (it != keys.end())
 295     {
 296       real_keys.push_back(const_cast<char *>((*it).c_str()));
 297       key_len.push_back((*it).length());
 298       ++it;
 299     }
 300
 301     /*
 302      * If the std::vector of keys is empty then we cannot
 303      * call memcached_mget as we will get undefined behavior.
 304      */
 305     if (not real_keys.empty())
 306     {
 307       return memcached_success(memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size()));
 308     }
 309
 310     return false;
 311   }
 312
 313   /**
 314    * Writes an object to the server. If the object already exists, it will
 315    * overwrite the existing object. This method always returns true
 316    * when using non-blocking mode unless a network error occurs.
 317    *
 318    * @param[in] key key of object to write to server
 319    * @param[in] value value of object to write to server
 320    * @param[in] expiration time to keep the object stored in the server for
 321    * @param[in] flags flags to store with the object
 322    * @return true on succcess; false otherwise
 323    */
 324   bool set(const std::string &key,
 325            const std::vector<char> &value,
 326            time_t expiration,
 327            uint32_t flags)
 328   {
 329     memcached_return_t rc= memcached_set(memc,
 330                                          key.c_str(), key.length(),
 331                                          &value[0], value.size(),
 332                                          expiration, flags);
 333     return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 334   }
 335
 336   /**
 337    * Writes an object to a server specified by the master_key parameter.
 338    * If the object already exists, it will overwrite the existing object.
 339    *
 340    * @param[in] master_key key that specifies server to write to
 341    * @param[in] key key of object to write to server
 342    * @param[in] value value of object to write to server
 343    * @param[in] expiration time to keep the object stored in the server for
 344    * @param[in] flags flags to store with the object
 345    * @return true on succcess; false otherwise
 346    */
 347   bool setByKey(const std::string &master_key,
 348                 const std::string &key,
 349                 const std::vector<char> &value,
 350                 time_t expiration,
 351                 uint32_t flags)
 352   {
 353     return memcached_success(memcached_set_by_key(memc, master_key.c_str(),
 354                                                   master_key.length(),
 355                                                   key.c_str(), key.length(),
 356                                                   &value[0], value.size(),
 357                                                   expiration,
 358                                                   flags));
 359   }
 360
 361   /**
 362    * Writes a list of objects to the server. Objects are specified by
 363    * 2 vectors - 1 vector of keys and 1 vector of values.
 364    *
 365    * @param[in] keys vector of keys of objects to write to server
 366    * @param[in] values vector of values of objects to write to server
 367    * @param[in] expiration time to keep the objects stored in server for
 368    * @param[in] flags flags to store with the objects
 369    * @return true on success; false otherwise
 370    */
 371   bool setAll(std::vector<std::string> &keys,
 372               std::vector< std::vector<char> *> &values,
 373               time_t expiration,
 374               uint32_t flags)
 375   {
 376     bool retval= true;
 377     std::vector<std::string>::iterator key_it= keys.begin();
 378     std::vector< std::vector<char> *>::iterator val_it= values.begin();
 379     while (key_it != keys.end())
 380     {
 381       retval= set((*key_it), *(*val_it), expiration, flags);
 382       if (retval == false)
 383       {
 384         return retval;
 385       }
 386       ++key_it;
 387       ++val_it;
 388     }
 389     return retval;
 390   }
 391
 392   /**
 393    * Writes a list of objects to the server. Objects are specified by
 394    * a map of keys to values.
 395    *
 396    * @param[in] key_value_map map of keys and values to store in server
 397    * @param[in] expiration time to keep the objects stored in server for
 398    * @param[in] flags flags to store with the objects
 399    * @return true on success; false otherwise
 400    */
 401   bool setAll(std::map<const std::string, std::vector<char> > &key_value_map,
 402               time_t expiration,
 403               uint32_t flags)
 404   {
 405     bool retval= true;
 406     std::map<const std::string, std::vector<char> >::iterator it= key_value_map.begin();
 407
 408     while (it != key_value_map.end())
 409     {
 410       retval= set(it->first, it->second, expiration, flags);
 411       if (retval == false)
 412       {
 413         // We should tell the user what the key that failed was
 414         return false;
 415       }
 416       ++it;
 417     }
 418     return true;
 419   }
 420
 421   /**
 422    * Increment the value of the object associated with the specified
 423    * key by the offset given. The resulting value is saved in the value
 424    * parameter.
 425    *
 426    * @param[in] key key of object in server whose value to increment
 427    * @param[in] offset amount to increment object's value by
 428    * @param[out] value store the result of the increment here
 429    * @return true on success; false otherwise
 430    */
 431   bool increment(const std::string &key, uint32_t offset, uint64_t *value)
 432   {
 433     return memcached_success(memcached_increment(memc, key.c_str(), key.length(), offset, value));
 434   }
 435
 436   /**
 437    * Decrement the value of the object associated with the specified
 438    * key by the offset given. The resulting value is saved in the value
 439    * parameter.
 440    *
 441    * @param[in] key key of object in server whose value to decrement
 442    * @param[in] offset amount to increment object's value by
 443    * @param[out] value store the result of the decrement here
 444    * @return true on success; false otherwise
 445    */
 446   bool decrement(const std::string &key, uint32_t offset, uint64_t *value)
 447   {
 448     return memcached_success(memcached_decrement(memc, key.c_str(),
 449                                                  key.length(),
 450                                                  offset, value));
 451   }
 452
 453
 454   /**
 455    * Add an object with the specified key and value to the server. This
 456    * function returns false if the object already exists on the server.
 457    *
 458    * @param[in] key key of object to add
 459    * @param[in] value of object to add
 460    * @return true on success; false otherwise
 461    */
 462   bool add(const std::string &key, const std::vector<char> &value)
 463   {
 464     return memcached_success(memcached_add(memc, key.c_str(), key.length(),
 465                                            &value[0], value.size(), 0, 0));
 466   }
 467
 468   /**
 469    * Add an object with the specified key and value to the server. This
 470    * function returns false if the object already exists on the server. The
 471    * server to add the object to is specified by the master_key parameter.
 472    *
 473    * @param[in[ master_key key of server to add object to
 474    * @param[in] key key of object to add
 475    * @param[in] value of object to add
 476    * @return true on success; false otherwise
 477    */
 478   bool addByKey(const std::string &master_key,
 479                 const std::string &key,
 480                 const std::vector<char> &value)
 481   {
 482     return memcached_success(memcached_add_by_key(memc,
 483                                                   master_key.c_str(),
 484                                                   master_key.length(),
 485                                                   key.c_str(),
 486                                                   key.length(),
 487                                                   &value[0],
 488                                                   value.size(),
 489                                                   0, 0));
 490   }
 491
 492   /**
 493    * Replaces an object on the server. This method only succeeds
 494    * if the object is already present on the server.
 495    *
 496    * @param[in] key key of object to replace
 497    * @param[in[ value value to replace object with
 498    * @return true on success; false otherwise
 499    */
 500   bool replace(const std::string &key, const std::vector<char> &value)
 501   {
 502     return memcached_success(memcached_replace(memc, key.c_str(), key.length(),
 503                                                &value[0], value.size(),
 504                                                0, 0));
 505   }
 506
 507   /**
 508    * Replaces an object on the server. This method only succeeds
 509    * if the object is already present on the server. The server
 510    * to replace the object on is specified by the master_key param.
 511    *
 512    * @param[in] master_key key of server to replace object on
 513    * @param[in] key key of object to replace
 514    * @param[in[ value value to replace object with
 515    * @return true on success; false otherwise
 516    */
 517   bool replaceByKey(const std::string &master_key,
 518                     const std::string &key,
 519                     const std::vector<char> &value)
 520   {
 521     return memcached_success(memcached_replace_by_key(memc,
 522                                                       master_key.c_str(),
 523                                                       master_key.length(),
 524                                                       key.c_str(),
 525                                                       key.length(),
 526                                                       &value[0],
 527                                                       value.size(),
 528                                                       0, 0));
 529   }
 530
 531   /**
 532    * Places a segment of data before the last piece of data stored.
 533    *
 534    * @param[in] key key of object whose value we will prepend data to
 535    * @param[in] value data to prepend to object's value
 536    * @return true on success; false otherwise
 537    */
 538   bool prepend(const std::string &key, const std::vector<char> &value)
 539   {
 540     return memcached_success(memcached_prepend(memc, key.c_str(), key.length(),
 541                                                &value[0], value.size(), 0, 0));
 542   }
 543
 544   /**
 545    * Places a segment of data before the last piece of data stored. The
 546    * server on which the object where we will be prepending data is stored
 547    * on is specified by the master_key parameter.
 548    *
 549    * @param[in] master_key key of server where object is stored
 550    * @param[in] key key of object whose value we will prepend data to
 551    * @param[in] value data to prepend to object's value
 552    * @return true on success; false otherwise
 553    */
 554   bool prependByKey(const std::string &master_key,
 555                     const std::string &key,
 556                     const std::vector<char> &value)
 557   {
 558     return memcached_success(memcached_prepend_by_key(memc,
 559                                                       master_key.c_str(),
 560                                                       master_key.length(),
 561                                                       key.c_str(),
 562                                                       key.length(),
 563                                                       &value[0],
 564                                                       value.size(),
 565                                                       0,
 566                                                       0));
 567   }
 568
 569   /**
 570    * Places a segment of data at the end of the last piece of data stored.
 571    *
 572    * @param[in] key key of object whose value we will append data to
 573    * @param[in] value data to append to object's value
 574    * @return true on success; false otherwise
 575    */
 576   bool append(const std::string &key, const std::vector<char> &value)
 577   {
 578     return memcached_success(memcached_append(memc,
 579                                               key.c_str(),
 580                                               key.length(),
 581                                               &value[0],
 582                                               value.size(),
 583                                               0, 0));
 584   }
 585
 586   /**
 587    * Places a segment of data at the end of the last piece of data stored. The
 588    * server on which the object where we will be appending data is stored
 589    * on is specified by the master_key parameter.
 590    *
 591    * @param[in] master_key key of server where object is stored
 592    * @param[in] key key of object whose value we will append data to
 593    * @param[in] value data to append to object's value
 594    * @return true on success; false otherwise
 595    */
 596   bool appendByKey(const std::string &master_key,
 597                    const std::string &key,
 598                    const std::vector<char> &value)
 599   {
 600     return memcached_success(memcached_append_by_key(memc,
 601                                                      master_key.c_str(),
 602                                                      master_key.length(),
 603                                                      key.c_str(),
 604                                                      key.length(),
 605                                                      &value[0],
 606                                                      value.size(),
 607                                                      0, 0));
 608   }
 609
 610   /**
 611    * Overwrite data in the server as long as the cas_arg value
 612    * is still the same in the server.
 613    *
 614    * @param[in] key key of object in server
 615    * @param[in] value value to store for object in server
 616    * @param[in] cas_arg "cas" value
 617    */
 618   bool cas(const std::string &key,
 619            const std::vector<char> &value,
 620            uint64_t cas_arg)
 621   {
 622     return memcached_success(memcached_cas(memc, key.c_str(), key.length(),
 623                                            &value[0], value.size(),
 624                                            0, 0, cas_arg));
 625   }
 626
 627   /**
 628    * Overwrite data in the server as long as the cas_arg value
 629    * is still the same in the server. The server to use is
 630    * specified by the master_key parameter.
 631    *
 632    * @param[in] master_key specifies server to operate on
 633    * @param[in] key key of object in server
 634    * @param[in] value value to store for object in server
 635    * @param[in] cas_arg "cas" value
 636    */
 637   bool casByKey(const std::string &master_key,
 638                 const std::string &key,
 639                 const std::vector<char> &value,
 640                 uint64_t cas_arg)
 641   {
 642     return memcached_success(memcached_cas_by_key(memc,
 643                                                   master_key.c_str(),
 644                                                   master_key.length(),
 645                                                   key.c_str(),
 646                                                   key.length(),
 647                                                   &value[0],
 648                                                   value.size(),
 649                                                   0, 0, cas_arg));
 650   }
 651
 652   /**
 653    * Delete an object from the server specified by the key given.
 654    *
 655    * @param[in] key key of object to delete
 656    * @return true on success; false otherwise
 657    */
 658   bool remove(const std::string &key)
 659   {
 660     return memcached_success(memcached_delete(memc, key.c_str(), key.length(), 0));
 661   }
 662
 663   /**
 664    * Delete an object from the server specified by the key given.
 665    *
 666    * @param[in] key key of object to delete
 667    * @param[in] expiration time to delete the object after
 668    * @return true on success; false otherwise
 669    */
 670   bool remove(const std::string &key, time_t expiration)
 671   {
 672     return memcached_success(memcached_delete(memc,
 673                                               key.c_str(),
 674                                               key.length(),
 675                                               expiration));
 676   }
 677
 678   /**
 679    * Delete an object from the server specified by the key given.
 680    *
 681    * @param[in] master_key specifies server to remove object from
 682    * @param[in] key key of object to delete
 683    * @return true on success; false otherwise
 684    */
 685   bool removeByKey(const std::string &master_key,
 686                    const std::string &key)
 687   {
 688     return memcached_success(memcached_delete_by_key(memc,
 689                                                      master_key.c_str(),
 690                                                      master_key.length(),
 691                                                      key.c_str(),
 692                                                      key.length(),
 693                                                      0));
 694   }
 695
 696   /**
 697    * Delete an object from the server specified by the key given.
 698    *
 699    * @param[in] master_key specifies server to remove object from
 700    * @param[in] key key of object to delete
 701    * @param[in] expiration time to delete the object after
 702    * @return true on success; false otherwise
 703    */
 704   bool removeByKey(const std::string &master_key,
 705                    const std::string &key,
 706                    time_t expiration)
 707   {
 708     return memcached_success(memcached_delete_by_key(memc,
 709                                                      master_key.c_str(),
 710                                                      master_key.length(),
 711                                                      key.c_str(),
 712                                                      key.length(),
 713                                                      expiration));
 714   }
 715
 716   /**
 717    * Wipe the contents of memcached servers.
 718    *
 719    * @param[in] expiration time to wait until wiping contents of
 720    *                       memcached servers
 721    * @return true on success; false otherwise
 722    */
 723   bool flush(time_t expiration= 0)
 724   {
 725     return memcached_success(memcached_flush(memc, expiration));
 726   }
 727
 728   /**
 729    * Get the library version string.
 730    * @return std::string containing a copy of the library version string.
 731    */
 732   const std::string libVersion() const
 733   {
 734     const char *ver= memcached_lib_version();
 735     const std::string version(ver);
 736     return version;
 737   }
 738
 739   /**
 740    * Retrieve memcached statistics. Populate a std::map with the retrieved
 741    * stats. Each server will map to another std::map of the key:value stats.
 742    *
 743    * @param[out] stats_map a std::map to be populated with the memcached
 744    *                       stats
 745    * @return true on success; false otherwise
 746    */
 747   bool getStats(std::map< std::string, std::map<std::string, std::string> >
 748                 &stats_map)
 749   {
 750     memcached_return_t rc;
 751     memcached_stat_st *stats= memcached_stat(memc, NULL, &rc);
 752
 753     if (rc != MEMCACHED_SUCCESS &&
 754         rc != MEMCACHED_SOME_ERRORS)
 755     {
 756       return false;
 757     }
 758
 759     uint32_t server_count= memcached_server_count(memc);
 760
 761     /*
 762      * For each memcached server, construct a std::map for its stats and add
 763      * it to the std::map of overall stats.
 764      */
 765     for (uint32_t x= 0; x < server_count; x++)
 766     {
 767       memcached_server_instance_st instance=
 768         memcached_server_instance_by_position(memc, x);
 769       std::ostringstream strstm;
 770       std::string server_name(memcached_server_name(instance));
 771       server_name.append(":");
 772       strstm << memcached_server_port(instance);
 773       server_name.append(strstm.str());
 774
 775       std::map<std::string, std::string> server_stats;
 776       char **list= NULL;
 777       char **ptr= NULL;
 778
 779       list= memcached_stat_get_keys(memc, &stats[x], &rc);
 780       for (ptr= list; *ptr; ptr++)
 781       {
 782         char *value= memcached_stat_get_value(memc, &stats[x], *ptr, &rc);
 783         server_stats[*ptr]= value;
 784         free(value);
 785       }
 786
 787       stats_map[server_name]= server_stats;
 788       free(list);
 789     }
 790
 791     memcached_stat_free(memc, stats);
 792     return true;
 793   }
 794
 795 private:
 796   memcached_st *memc;
 797 };
 798
 799 }