MemCacheClient.h

Go to the documentation of this file.

#ifndef INCLUDED_MemCacheClient
#define INCLUDED_MemCacheClient

#ifndef WIN32
# include <stdint.h>
#endif

#include <string>
#include <vector>

#include "ReadWriteBuffer.h"

// ----------------------------------------------------------------------------
enum MCResult { 
    // success: n >= 0
    MCERR_OK        = 0,    
    MCERR_NOREPLY   = 1,    
    MCERR_NOTSTORED = 2,    
    MCERR_NOTFOUND  = 3,    

    // failure: n < 0
    MCERR_NOSERVER  = -1    
};

// ----------------------------------------------------------------------------
class MemCacheClient 
{
    class Server;                           

public:
    typedef std::string         string_t;   
#ifdef WIN32
    typedef unsigned __int64    uint64_t;   
#else
    typedef unsigned long long  uint64_t;   
#endif

    struct MemRequest 
    {
        struct Sort;        
        Server * mServer;   

    public:
        MemRequest() { Clear(); }

        void Clear() { 
            mServer = NULL;
            mKey    = "";
            mFlags  = 0;
            mExpiry = 0; 
            mCas    = 0;
            mResult = MCERR_OK;
            mData.SetEmpty();
        }

    public:
        string_t mKey;

        unsigned int mFlags;

        time_t mExpiry; 

        uint64_t mCas;

        MCResult mResult; 

        ReadWriteBuffer mData;
    };

public:
    const static int MAX_REQUESTS = 20;

    MemCacheClient();

    MemCacheClient(const MemCacheClient &); 

    MemCacheClient & operator=(const MemCacheClient &); 

    ~MemCacheClient();

    void SetTimeout(int a_nTimeoutMs);

    /*-----------------------------------------------------------------------*/
    bool AddServer(const char * a_pszServer);

    bool DelServer(const char * a_pszServer);

    void GetServers(std::vector<string_t> & a_rgServers);

    void ClearServers();

    /*-----------------------------------------------------------------------*/
    inline int Add(MemRequest & a_oItem) { return Store("add", &a_oItem, 1); }

    inline int Set(MemRequest & a_oItem) { return Store("set", &a_oItem, 1); }

    inline int Replace(MemRequest & a_oItem) { return Store("replace", &a_oItem, 1); }

    inline int Append(MemRequest & a_oItem) { return Store("append", &a_oItem, 1); }

    inline int Prepend(MemRequest & a_oItem) { return Store("prepend", &a_oItem, 1); }

    inline int CheckSet(MemRequest & a_oItem) { return Store("cas", &a_oItem, 1); }

    inline int Get(MemRequest & a_oItem) { return Combine("get", &a_oItem, 1); }

    inline int Gets(MemRequest & a_oItem) { return Combine("gets", &a_oItem, 1); }

    inline int Del(MemRequest & a_oItem) { return Combine("del", &a_oItem, 1); }


    inline MCResult Increment(const char * a_pszKey, uint64_t * a_pnNewValue = NULL, uint64_t a_nDiff = 1, bool a_bWantReply = true) { 
        return IncDec("incr", a_pszKey, a_pnNewValue, a_nDiff, a_bWantReply);
    }

    inline MCResult Decrement(const char * a_pszKey, uint64_t * a_pnNewValue = NULL, uint64_t a_nDiff = 1, bool a_bWantReply = true) { 
        return IncDec("decr", a_pszKey, a_pnNewValue, a_nDiff, a_bWantReply); 
    }

    /*-----------------------------------------------------------------------*/
    inline int Add(MemRequest * a_rgItem, int a_nCount) { return Store("add", a_rgItem, a_nCount); }

    inline int Set(MemRequest * a_rgItem, int a_nCount) { return Store("set", a_rgItem, a_nCount); }

    inline int Replace(MemRequest * a_rgItem, int a_nCount) { return Store("replace", a_rgItem, a_nCount); }

    inline int Append(MemRequest * a_rgItem, int a_nCount) { return Store("append", a_rgItem, a_nCount); }

    inline int Prepend(MemRequest * a_rgItem, int a_nCount) { return Store("prepend", a_rgItem, a_nCount); }

    inline int CheckSet(MemRequest * a_rgItem, int a_nCount) { return Store("cas", a_rgItem, a_nCount); }

    inline int Get(MemRequest * a_rgItem, int a_nCount) { return Combine("get", a_rgItem, a_nCount); }

    inline int Gets(MemRequest * a_rgItem, int a_nCount) { return Combine("gets", a_rgItem, a_nCount); }

    inline int Del(MemRequest * a_rgItem, int a_nCount) { return Combine("del", a_rgItem, a_nCount); }

    int FlushAll(const char * a_pszServer = NULL, int a_nExpiry = 0);

private:
    /*-----------------------------------------------------------------------*/
    std::vector<Server*> m_rgpServer;       

    int m_nTimeoutMs;                       

    struct ConsistentHash { 
        unsigned long   mHash;      
        Server *        mServer;    

        ConsistentHash(unsigned long aHash, Server * aServer) 
            : mHash(aHash), mServer(aServer) { }
        ConsistentHash(const ConsistentHash & rhs) { operator=(rhs); }
        ConsistentHash & operator=(const ConsistentHash & rhs) {
            mHash = rhs.mHash; mServer = rhs.mServer; return *this; }
        bool operator<(const ConsistentHash & rhs) const { return mHash < rhs.mHash; }
        bool operator==(const ConsistentHash & rhs) const { return mHash == rhs.mHash; }
        struct MatchServer;
    };

    std::vector<ConsistentHash> m_rgServerHash;

    unsigned long CreateKeyHash(const char * a_pszKey);

    Server * FindServer(const string_t & a_sKey);

    int Store(const char * a_pszType, MemRequest * a_rgItem, int a_nCount);

    void HandleStoreResponse(Server * a_pServer, MemRequest & a_oItem);
    
    int Combine(const char * a_pszType, MemRequest * a_rgItem, int a_nCount);

    int HandleGetResponse(Server * a_pServer, MemRequest ** a_ppBegin, MemRequest ** a_ppEnd);

    int HandleDelResponse(Server * a_pServer, MemRequest ** a_ppBegin, MemRequest ** a_ppEnd);

    MCResult IncDec(const char * a_pszType, const char * a_pszKey, uint64_t * a_pnNewValue, uint64_t a_nDiff, bool a_bWantReply);

};

#endif // INCLUDED_MemCacheClient

---