ald-rpc.h

См. документацию.

 
#ifndef ALD_RPC
#define ALD_RPC
 
#define ARPCM_ERROR       0x0
#define ARPCM_CALL        0x10
#define ARPCM_ECALL       0x11
#define ARPCM_RESULT      0x20
#define ARPCM_ERESULT     0x21
#define ARPCM_LOCAL_REQ   0x30
#define ARPCM_LOCAL_RES   0x31
#define ARPCM_BROAD_MSG   0x40
#define ARPCM_BROAD_RES   0x41
 
#define ALDRPCSERVICE "aldd"
 
#define ALDRPCMAGIC "ALDRPC01"
 
#define ALDRPCVERSION  100
 
struct ald_rpc_header {
    char            magic[8];
    unsigned short  version;
    unsigned short  message;
    unsigned long   size;
};
 
#ifdef __cplusplus
 
#include "common.h"
#include "ALDCore.h"
#include "gettext.h"
 
using namespace std;
 
namespace ALD
{
 
#define ALD_RPC_ITF_NAME "ald-rpc"
 
const size_t ALDRPCHDRSIZE = sizeof(ald_rpc_header);
 
enum alRPCStatus {alrsINI, alrsOK, alrsWAIT, alrsERR};
 
struct ald_rpc_request {
    ald_rpc_header header;
    string name;
    ald_string_multimap args;
    ald_string_multimap result;
    alRPCStatus status;
    string error;
 
    inline bool good() const {return alrsOK == status;}
 
    inline void addArg(const string &arg, const string &val){args.insert(make_pair(arg, val));}
 
    inline void addRes(const string &res, const string &val){result.insert(make_pair(res, val));}
 
    inline void setError(const string &err){error = err;status = alrsERR;}
 
    inline string argByName(const string& key){
        ald_string_multimap::const_iterator it = args.find(key);
        if(it != args.end())
            return it->second;
        else
            return "";
    }
 
    inline string resByName(const string& key){
        ald_string_multimap::const_iterator it = result.find(key);
        if(it != result.end())
            return it->second;
        else
            return "";
    }
 
    inline bool argExists(const string& key){
        ald_string_multimap::const_iterator it = args.find(key);
        return (it != args.end());
    }
 
    inline bool resExists(const string& key){
        ald_string_multimap::const_iterator it = result.find(key);
        return (it != result.end());
    }
 
    inline void clear(){args.clear(); result.clear();}
};
 
class IALDRpcConnection
{
public:
    virtual ALDAuthType AuthType() = 0;
    virtual int getTimeout() const = 0;
    virtual void setTimeout(int timeout) = 0;
 
    virtual bool Connect(const string &server, ALDAuthType at) = 0;
    virtual bool IsConnected() = 0;
    virtual void Disconnect() = 0;
 
    virtual void Call(ald_rpc_request& req) = 0;
    virtual alRPCStatus CallEx(ald_rpc_request& req) = 0;
 
    virtual ~IALDRpcConnection(){}
};
 
typedef shared_ptr<IALDRpcConnection> CALDRpcConnPtr;
 
class IALDRpcWrapper: public CALDInterface
{
public:
    IALDRpcWrapper(IALDCore& Core):CALDInterface(ALD_RPC_ITF_NAME, Core){}
    virtual size_t SendBroadcastMessage(const string& msg, ald_string_list *responses, int timeout = 3) = 0;
    virtual CALDRpcConnPtr getConnection() = 0;
};
 
typedef shared_ptr<IALDRpcWrapper> CALDRpcWrapperPtr;
 
} /* ALD */
 
#endif /* ALD_RPC */
 
#endif /* __cplusplus */