封装 libmemcached

对 libmemcached进行二次封装，主要是利用其存储 vector<T>。

下面有待改善和完善，先记着，下次更新。

#include <iostream>
#include <string>
#include <libmemcached/memcached.h>
#include <vector>

using namespace std;

class MemcachedHelper
{
    time_t expiration;
    uint32_t  flags;
    memcached_st *memc;
      memcached_return rc;
      memcached_server_st *server;
  public:
    MemcachedHelper()
    {
        memc = memcached_create(NULL);
        server = memcached_server_list_append(NULL,"10.10.10.233",11211,&rc);
        rc=memcached_server_push(memc,server);
        memcached_server_list_free(server);
        expiration = 100;
    }
    ~MemcachedHelper()
    {
        memcached_free(memc);
    }
    public:
    template<class T> void set(string in_key,vector<T> in_vect)
    {
        char* valueChar = new char[sizeof(T)* in_vect.size()];
        memcpy(valueChar, &in_vect[0], sizeof(T)* in_vect.size());
        size_t value_length = sizeof(T)* in_vect.size();    
        rc=memcached_set(memc,in_key.c_str(),in_key.length(),valueChar,value_length,expiration,flags);
        if(rc==MEMCACHED_SUCCESS)
        {
            cout<<"Set: "<<in_key<<" OK!"<<endl;
        }
        delete valueChar;
    }
    public:    
    template<class T> void get(string in_key,vector<T>& in_vect)
    {    
        size_t value_length = 0;
        size_t key_length = in_key.length();
        char* result = memcached_get(memc,in_key.c_str(), key_length,&value_length,&flags,&rc);
        if(rc == MEMCACHED_SUCCESS)
        {
            in_vect.reserve(value_length / (sizeof(T)));
            memcpy(&in_vect[0], result, value_length);
            cout<<"Get: "<<in_key<<" OK!"<<endl;
        }
    }    
};


class Product
{
public:
    Product(){}
    Product(int in_id, int in_price)
    {
        id = in_id;
        price = in_price;
    }

public:
    int id;
    int price;
public:
    int getid(){return id;}
    int getprice(){return price;}
};


int main()
{
    Product product1(1,1);
    Product product2(2,2);
    Product product3(30,30);
    vector<Product> product;
    product.push_back(product1);
    product.push_back(product2);
    product.push_back(product3);

    MemcachedHelper mem;

    mem.set("oo",product);
    
    vector<Product> result;
    mem.get("oo",result);
    cout<<result[2].id<<endl;
}

改进版（仍有待改进）：

#include <iostream>
#include <string>
#include <libmemcached/memcached.h>
#include <vector>

#pragma once

using namespace std;


class MemcachedHelper
{
    time_t expiration;
    uint32_t  flags;
    memcached_st *memc;
      memcached_return rc;
      memcached_server_st *server;
  public:
    MemcachedHelper()
    {
        memc = memcached_create(NULL);
        server = memcached_server_list_append(NULL,"10.10.10.233",11211,&rc);
        rc=memcached_server_push(memc,server);
        memcached_server_list_free(server);
        expiration = 1000000;
    }
    ~MemcachedHelper()
    {
        memcached_free(memc);
    }
    
    public:
    int set(string in_key,string in_value)
    {
        rc=memcached_set(memc,in_key.c_str(),in_key.length(),in_value.c_str(),in_value.length(),expiration,flags);
        if(rc==MEMCACHED_SUCCESS)
            return 1;
        else
            return 0;
    }
    
    public:
    template<class T> int set(string in_key,vector<T> &in_vect)
    {
        char* valueChar = new char[sizeof(T)* in_vect.size()];
        memcpy(valueChar, &in_vect[0], sizeof(T)* in_vect.size());
        size_t value_length = sizeof(T)* in_vect.size();    
        rc=memcached_set(memc,in_key.c_str(),in_key.length(),valueChar,value_length,expiration,flags);
        if(rc==MEMCACHED_SUCCESS)
            return 1;
        else
            return 0;
        delete valueChar;
    }
    
    public:    
    int get(string in_key,string &out_value)
    {    
        size_t value_length = 0;
        char* result = memcached_get(memc,in_key.c_str(), in_key.length(),&value_length,&flags,&rc);
        if(rc == MEMCACHED_SUCCESS)
        {
            out_value = result;
            return 1;
        }
        else
        {
            return 0;
        }
    }    
    
    public:    
    template<class T> int get(string in_key,vector<T>& in_vect)
    {    
        size_t value_length = 0;
        size_t key_length = in_key.length();
        char* result = memcached_get(memc,in_key.c_str(), key_length,&value_length,&flags,&rc);
        if(rc == MEMCACHED_SUCCESS)
        {
            in_vect.reserve(value_length / (sizeof(T)));
            memcpy(&in_vect[0], result, value_length);
            in_vect.assign(in_vect.begin(),in_vect.begin()+value_length/(sizeof(T)));
            //cout<<"Get: "<<in_key<<" OK!"<<endl;
            //size = value_length/sizeof(T);
            return 1;
        }
        else
        {
            return 0;
        }
    }    
};