X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=libmemcached%2Fmemcached.hpp;h=8c5ca934c9055fda7b1539d927256697f1a53ac9;hb=3e87de62b0b39279bdec62a07b45e42fe798fd41;hp=b0985715ed06d5403fa5981954cd281b3c32c8de;hpb=67456d74f5bd4f354a360d70da503dc58cbe5971;p=m6w6%2Flibmemcached

diff --git a/libmemcached/memcached.hpp b/libmemcached/memcached.hpp
index b0985715..8c5ca934 100644
--- a/libmemcached/memcached.hpp
+++ b/libmemcached/memcached.hpp
@@ -35,67 +35,39 @@ class Memcache
 {
 public:
 
-  Memcache() :
-      servers_list(),
-      memc(),
-      result()
+  Memcache()
   {
-    memcached_create(&memc);
+    memc= memcached("", 0);
   }
 
-  Memcache(const std::string &in_servers_list)
-    :
-      servers_list(in_servers_list),
-      memc(),
-      result()
+  Memcache(const std::string &config)
   {
-    memcached_create(&memc);
-    init();
+    memc= memcached(config.c_str(), config.size());
   }
 
-  Memcache(const std::string &hostname,
-           in_port_t port)
-    :
-      servers_list(),
-      memc(),
-      result()
+  Memcache(const std::string &hostname, in_port_t port)
   {
-    memcached_create(&memc);
-
-    servers_list.append(hostname);
-    servers_list.append(":");
-    std::ostringstream strsmt;
-    strsmt << port;
-    servers_list.append(strsmt.str());
-
-    init();
+    memc= memcached("", 0);
+    if (memc)
+      memcached_server_add(memc, hostname.c_str(), port);
   }
 
   Memcache(memcached_st *clone)
-    :
-      servers_list(),
-      memc(),
-      result()
   {
-    memcached_clone(&memc, clone);
+    memc= memcached_clone(NULL, clone);
   }
 
   Memcache(const Memcache &rhs)
-    :
-      servers_list(rhs.servers_list),
-      memc(),
-      result()
   {
-    memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
-    init();
+    memc= memcached_clone(NULL, rhs.getImpl());
   }
 
   Memcache &operator=(const Memcache &rhs)
   {
     if (this != &rhs)
     {
-      memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
-      init();
+      memcached_free(memc);
+      memc= memcached_clone(NULL, rhs.getImpl());
     }
 
     return *this;
@@ -103,29 +75,13 @@ public:
 
   ~Memcache()
   {
-    memcached_free(&memc);
-  }
-
-  void init()
-  {
-    memcached_server_st *servers;
-    servers= memcached_servers_parse(servers_list.c_str());
-    memcached_server_push(&memc, servers);
-    memcached_server_free(servers);
-  }
-
-  /**
-   * Get the internal memcached_st *
-   */
-  memcached_st &getImpl()
-  {
-    return memc;
+    memcached_free(memc);
   }
 
   /**
    * Get the internal memcached_st *
    */
-  const memcached_st &getImpl() const
+  const memcached_st *getImpl() const
   {
     return memc;
   }
@@ -142,41 +98,62 @@ public:
     return memcached_strerror(NULL, rc);
   }
 
+  bool error(std::string& error_message) const
+  {
+    if (memcached_failed(memcached_last_error(memc)))
+    {
+      error_message+= memcached_last_error_message(memc);
+      return true;
+    }
 
-  bool setBehavior(memcached_behavior_t flag, uint64_t data)
+    return false;
+  }
+
+  bool error() const
   {
-    memcached_return_t rc;
-    rc= memcached_behavior_set(&memc, flag, data);
-    return (rc == MEMCACHED_SUCCESS);
+    if (memcached_failed(memcached_last_error(memc)))
+    {
+      return true;
+    }
+
+    return false;
   }
 
-  uint64_t getBehavior(memcached_behavior_t flag) {
-    return memcached_behavior_get(&memc, flag);
+  bool error(memcached_return_t& arg) const
+  {
+    arg= memcached_last_error(memc);
+    return memcached_failed(arg);
   }
 
-  /**
-   * Return the string which contains the list of memcached servers being
-   * used.
-   *
-   * @return a std::string containing the list of memcached servers
-   */
-  const std::string getServersList() const
+  bool setBehavior(memcached_behavior_t flag, uint64_t data)
+  {
+    return (memcached_success(memcached_behavior_set(memc, flag, data)));
+  }
+
+  uint64_t getBehavior(memcached_behavior_t flag)
   {
-    return servers_list;
+    return memcached_behavior_get(memc, flag);
   }
 
   /**
-   * Set the list of memcached servers to use.
+   * Configure the memcache object
    *
-   * @param[in] in_servers_list list of servers
+   * @param[in] in_config configuration
    * @return true on success; false otherwise
    */
-  bool setServers(const std::string &in_servers_list)
+  bool configure(const std::string &configuration)
   {
-    servers_list.assign(in_servers_list);
-    init();
+    memcached_st *new_memc= memcached(configuration.c_str(), configuration.size());
 
-    return (memcached_server_count(&memc));
+    if (new_memc)
+    {
+      memcached_free(memc);
+      memc= new_memc;
+
+      return true;
+    }
+
+    return false;
   }
 
   /**
@@ -188,11 +165,7 @@ public:
    */
   bool addServer(const std::string &server_name, in_port_t port)
   {
-    memcached_return_t rc;
-
-    rc= memcached_server_add(&memc, server_name.c_str(), port);
-
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_server_add(memc, server_name.c_str(), port));
   }
 
   /**
@@ -226,30 +199,41 @@ public:
    * @return a memcached return structure
    */
   memcached_return_t fetch(std::string &key,
-                         std::vector<char> &ret_val)
+                           std::vector<char> &ret_val,
+                           uint32_t &flags,
+                           uint64_t &cas_value)
   {
-    char ret_key[MEMCACHED_MAX_KEY];
-    size_t value_length= 0;
-    size_t key_length= 0;
     memcached_return_t rc;
-    uint32_t flags= 0;
-    char *value= memcached_fetch(&memc, ret_key, &key_length,
-                                 &value_length, &flags, &rc);
-    if (value && ret_val.empty())
-    {
-      ret_val.reserve(value_length);
-      ret_val.assign(value, value + value_length);
-      key.assign(ret_key, key_length);
-      free(value);
-    }
-    else if (value)
+
+    memcached_result_st *result;
+    if ((result= memcached_fetch_result(memc, NULL, &rc)))
     {
-      free(value);
+      // Key
+      key.assign(memcached_result_key_value(result), memcached_result_key_length(result));
+
+      // Actual value, null terminated
+      ret_val.reserve(memcached_result_length(result) +1);
+      ret_val.assign(memcached_result_value(result), 
+                     memcached_result_value(result) +memcached_result_length(result));
+
+      // Misc
+      flags= memcached_result_flags(result);
+      cas_value= memcached_result_cas(result);
     }
+    memcached_result_free(result);
 
     return rc;
   }
 
+  memcached_return_t fetch(std::string &key,
+                           std::vector<char> &ret_val)
+  {
+    uint32_t flags= 0;
+    uint64_t cas_value= 0;
+
+    return fetch(key, ret_val, flags, cas_value);
+  }
+
   /**
    * Fetches an individual value from the server.
    *
@@ -264,7 +248,7 @@ public:
     memcached_return_t rc;
     size_t value_length= 0;
 
-    char *value= memcached_get(&memc, key.c_str(), key.length(),
+    char *value= memcached_get(memc, key.c_str(), key.length(),
                                &value_length, &flags, &rc);
     if (value != NULL && ret_val.empty())
     {
@@ -273,6 +257,7 @@ public:
       free(value);
       return true;
     }
+
     return false;
   }
 
@@ -296,7 +281,7 @@ public:
     memcached_return_t rc;
     size_t value_length= 0;
 
-    char *value= memcached_get_by_key(&memc,
+    char *value= memcached_get_by_key(memc,
                                       master_key.c_str(), master_key.length(),
                                       key.c_str(), key.length(),
                                       &value_length, &flags, &rc);
@@ -343,11 +328,9 @@ public:
      * If the std::vector of keys is empty then we cannot
      * call memcached_mget as we will get undefined behavior.
      */
-    if (! real_keys.empty())
+    if (not real_keys.empty())
     {
-      memcached_return_t rc= memcached_mget(&memc, &real_keys[0], &key_len[0],
-                                          real_keys.size());
-      return (rc == MEMCACHED_SUCCESS);
+      return memcached_success(memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size()));
     }
 
     return false;
@@ -369,11 +352,11 @@ public:
            time_t expiration,
            uint32_t flags)
   {
-    memcached_return_t rc= memcached_set(&memc,
-                                       key.c_str(), key.length(),
-                                       &value[0], value.size(),
-                                       expiration, flags);
-    return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+    memcached_return_t rc= memcached_set(memc,
+                                         key.c_str(), key.length(),
+                                         &value[0], value.size(),
+                                         expiration, flags);
+    return memcached_success(rc);
   }
 
   /**
@@ -393,13 +376,12 @@ public:
                 time_t expiration,
                 uint32_t flags)
   {
-    memcached_return_t rc= memcached_set_by_key(&memc, master_key.c_str(),
-                                              master_key.length(),
-                                              key.c_str(), key.length(),
-                                              &value[0], value.size(),
-                                              expiration,
-                                              flags);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_set_by_key(memc, master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(), key.length(),
+                                                  &value[0], value.size(),
+                                                  expiration,
+                                                  flags));
   }
 
   /**
@@ -474,9 +456,7 @@ public:
    */
   bool increment(const std::string &key, uint32_t offset, uint64_t *value)
   {
-    memcached_return_t rc= memcached_increment(&memc, key.c_str(), key.length(),
-                                             offset, value);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_increment(memc, key.c_str(), key.length(), offset, value));
   }
 
   /**
@@ -491,10 +471,9 @@ public:
    */
   bool decrement(const std::string &key, uint32_t offset, uint64_t *value)
   {
-    memcached_return_t rc= memcached_decrement(&memc, key.c_str(),
-                                             key.length(),
-                                             offset, value);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_decrement(memc, key.c_str(),
+                                                 key.length(),
+                                                 offset, value));
   }
 
 
@@ -508,9 +487,8 @@ public:
    */
   bool add(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_add(&memc, key.c_str(), key.length(),
-                                       &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_add(memc, key.c_str(), key.length(),
+                                           &value[0], value.size(), 0, 0));
   }
 
   /**
@@ -527,15 +505,14 @@ public:
                 const std::string &key,
                 const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_add_by_key(&memc,
-                                              master_key.c_str(),
-                                              master_key.length(),
-                                              key.c_str(),
-                                              key.length(),
-                                              &value[0],
-                                              value.size(),
-                                              0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_add_by_key(memc,
+                                                  master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(),
+                                                  key.length(),
+                                                  &value[0],
+                                                  value.size(),
+                                                  0, 0));
   }
 
   /**
@@ -548,10 +525,9 @@ public:
    */
   bool replace(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_replace(&memc, key.c_str(), key.length(),
-                                           &value[0], value.size(),
-                                           0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_replace(memc, key.c_str(), key.length(),
+                                               &value[0], value.size(),
+                                               0, 0));
   }
 
   /**
@@ -568,15 +544,14 @@ public:
                     const std::string &key,
                     const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_replace_by_key(&memc,
-                                                  master_key.c_str(),
-                                                  master_key.length(),
-                                                  key.c_str(),
-                                                  key.length(),
-                                                  &value[0],
-                                                  value.size(),
-                                                  0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_replace_by_key(memc,
+                                                      master_key.c_str(),
+                                                      master_key.length(),
+                                                      key.c_str(),
+                                                      key.length(),
+                                                      &value[0],
+                                                      value.size(),
+                                                      0, 0));
   }
 
   /**
@@ -588,9 +563,8 @@ public:
    */
   bool prepend(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_prepend(&memc, key.c_str(), key.length(),
-                                           &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_prepend(memc, key.c_str(), key.length(),
+                                               &value[0], value.size(), 0, 0));
   }
 
   /**
@@ -607,16 +581,15 @@ public:
                     const std::string &key,
                     const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_prepend_by_key(&memc,
-                                                  master_key.c_str(),
-                                                  master_key.length(),
-                                                  key.c_str(),
-                                                  key.length(),
-                                                  &value[0],
-                                                  value.size(),
-                                                  0,
-                                                  0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_prepend_by_key(memc,
+                                                      master_key.c_str(),
+                                                      master_key.length(),
+                                                      key.c_str(),
+                                                      key.length(),
+                                                      &value[0],
+                                                      value.size(),
+                                                      0,
+                                                      0));
   }
 
   /**
@@ -628,13 +601,12 @@ public:
    */
   bool append(const std::string &key, const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_append(&memc,
-                                            key.c_str(),
-                                            key.length(),
-                                            &value[0],
-                                            value.size(),
-                                            0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_append(memc,
+                                              key.c_str(),
+                                              key.length(),
+                                              &value[0],
+                                              value.size(),
+                                              0, 0));
   }
 
   /**
@@ -651,15 +623,14 @@ public:
                    const std::string &key,
                    const std::vector<char> &value)
   {
-    memcached_return_t rc= memcached_append_by_key(&memc,
-                                                   master_key.c_str(),
-                                                   master_key.length(),
-                                                   key.c_str(),
-                                                   key.length(),
-                                                   &value[0],
-                                                   value.size(),
-                                                   0, 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_append_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     &value[0],
+                                                     value.size(),
+                                                     0, 0));
   }
 
   /**
@@ -674,10 +645,9 @@ public:
            const std::vector<char> &value,
            uint64_t cas_arg)
   {
-    memcached_return_t rc= memcached_cas(&memc, key.c_str(), key.length(),
-                                       &value[0], value.size(),
-                                       0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_cas(memc, key.c_str(), key.length(),
+                                           &value[0], value.size(),
+                                           0, 0, cas_arg));
   }
 
   /**
@@ -695,15 +665,14 @@ public:
                 const std::vector<char> &value,
                 uint64_t cas_arg)
   {
-    memcached_return_t rc= memcached_cas_by_key(&memc,
-                                              master_key.c_str(),
-                                              master_key.length(),
-                                              key.c_str(),
-                                              key.length(),
-                                              &value[0],
-                                              value.size(),
-                                              0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_cas_by_key(memc,
+                                                  master_key.c_str(),
+                                                  master_key.length(),
+                                                  key.c_str(),
+                                                  key.length(),
+                                                  &value[0],
+                                                  value.size(),
+                                                  0, 0, cas_arg));
   }
 
   /**
@@ -714,8 +683,7 @@ public:
    */
   bool remove(const std::string &key)
   {
-    memcached_return_t rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete(memc, key.c_str(), key.length(), 0));
   }
 
   /**
@@ -727,11 +695,10 @@ public:
    */
   bool remove(const std::string &key, time_t expiration)
   {
-    memcached_return_t rc= memcached_delete(&memc,
-                                          key.c_str(),
-                                          key.length(),
-                                          expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete(memc,
+                                              key.c_str(),
+                                              key.length(),
+                                              expiration));
   }
 
   /**
@@ -744,13 +711,12 @@ public:
   bool removeByKey(const std::string &master_key,
                    const std::string &key)
   {
-    memcached_return_t rc= memcached_delete_by_key(&memc,
-                                                 master_key.c_str(),
-                                                 master_key.length(),
-                                                 key.c_str(),
-                                                 key.length(),
-                                                 0);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     0));
   }
 
   /**
@@ -765,13 +731,12 @@ public:
                    const std::string &key,
                    time_t expiration)
   {
-    memcached_return_t rc= memcached_delete_by_key(&memc,
-                                                 master_key.c_str(),
-                                                 master_key.length(),
-                                                 key.c_str(),
-                                                 key.length(),
-                                                 expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_delete_by_key(memc,
+                                                     master_key.c_str(),
+                                                     master_key.length(),
+                                                     key.c_str(),
+                                                     key.length(),
+                                                     expiration));
   }
 
   /**
@@ -781,10 +746,9 @@ public:
    *                       memcached servers
    * @return true on success; false otherwise
    */
-  bool flush(time_t expiration)
+  bool flush(time_t expiration= 0)
   {
-    memcached_return_t rc= memcached_flush(&memc, expiration);
-    return (rc == MEMCACHED_SUCCESS);
+    return memcached_success(memcached_flush(memc, expiration));
   }
 
   /**
@@ -810,7 +774,7 @@ public:
                 &stats_map)
   {
     memcached_return_t rc;
-    memcached_stat_st *stats= memcached_stat(&memc, NULL, &rc);
+    memcached_stat_st *stats= memcached_stat(memc, NULL, &rc);
 
     if (rc != MEMCACHED_SUCCESS &&
         rc != MEMCACHED_SOME_ERRORS)
@@ -818,7 +782,7 @@ public:
       return false;
     }
 
-    uint32_t server_count= memcached_server_count(&memc);
+    uint32_t server_count= memcached_server_count(memc);
 
     /*
      * For each memcached server, construct a std::map for its stats and add
@@ -827,7 +791,7 @@ public:
     for (uint32_t x= 0; x < server_count; x++)
     {
       memcached_server_instance_st instance=
-        memcached_server_instance_by_position(&memc, x);
+        memcached_server_instance_by_position(memc, x);
       std::ostringstream strstm;
       std::string server_name(memcached_server_name(instance));
       server_name.append(":");
@@ -838,10 +802,10 @@ public:
       char **list= NULL;
       char **ptr= NULL;
 
-      list= memcached_stat_get_keys(&memc, &stats[x], &rc);
+      list= memcached_stat_get_keys(memc, &stats[x], &rc);
       for (ptr= list; *ptr; ptr++)
       {
-        char *value= memcached_stat_get_value(&memc, &stats[x], *ptr, &rc);
+        char *value= memcached_stat_get_value(memc, &stats[x], *ptr, &rc);
         server_stats[*ptr]= value;
         free(value);
       }
@@ -850,15 +814,12 @@ public:
       free(list);
     }
 
-    memcached_stat_free(&memc, stats);
+    memcached_stat_free(memc, stats);
     return true;
   }
 
 private:
-
-  std::string servers_list;
-  memcached_st memc;
-  memcached_result_st result;
+  memcached_st *memc;
 };
 
 }