test_peer_base.hh

/*
 * obj/i686-pc-linux-gnu/xrl/targets/test_peer_base.hh
 * vim:set sts=4 ts=8 ft=cpp:
 *
 * Copyright (c) 2001-2011 XORP, Inc and Others
 * See the XORP LICENSE.lgpl file for licensing, conditions, and warranties
 * on use.
 *
 * DO NOT EDIT THIS FILE - IT IS PROGRAMMATICALLY GENERATED
 *
 * Generated by 'tgt-gen'.
 */


#ifndef __XRL_TARGETS_TEST_PEER_BASE_HH__
#define __XRL_TARGETS_TEST_PEER_BASE_HH__

#undef XORP_LIBRARY_NAME
#define XORP_LIBRARY_NAME "XrlTestPeerTarget"

#include "libxorp/xlog.h"
#include "libxipc/xrl_cmd_map.hh"

class XrlTestPeerTargetBase {
protected:
    XrlCmdMap* _cmds;

public:
    XrlTestPeerTargetBase(XrlCmdMap* cmds = 0);

    virtual ~XrlTestPeerTargetBase();

    bool set_command_map(XrlCmdMap* cmds);

    const string& get_name() const { return _cmds->name(); }

    const char* version() const { return "test_peer/0.0"; }

protected:

    virtual XrlCmdError common_0_1_get_target_name(
    // Output values,
    string& name) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback2<void, const XrlCmdError &,
    const string*>::RefPtr
    Common01GetTargetNameRF;

    class Common01GetTargetNameCB {
        Common01GetTargetNameRF cb;

    public:
        operator const Common01GetTargetNameRF& () const { return cb; }
        const Common01GetTargetNameRF& operator ->() const { return cb; }
        Common01GetTargetNameCB(const Common01GetTargetNameRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }

        void respond(const string& arg_name) const {
            cb->dispatch(XrlCmdError::OKAY(),
                         &arg_name);
        }
    };

    struct Common01GetTargetNameRsp :
      public Common01GetTargetNameCB {
        struct args_str {
            string name;
        };

    private:
        args_str args;

    public:
        Common01GetTargetNameRsp(const Common01GetTargetNameRF& cb)
          : Common01GetTargetNameCB(cb) { }

        void respond() const {
            Common01GetTargetNameCB::
            respond(args.name);
        }

        args_str* operator ->() {
            return &args;
        }
    };

    virtual void async_common_0_1_get_target_name
       (
    Common01GetTargetNameCB);
#endif

    virtual XrlCmdError common_0_1_get_version(
    // Output values,
    string& version) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback2<void, const XrlCmdError &,
    const string*>::RefPtr
    Common01GetVersionRF;

    class Common01GetVersionCB {
        Common01GetVersionRF cb;

    public:
        operator const Common01GetVersionRF& () const { return cb; }
        const Common01GetVersionRF& operator ->() const { return cb; }
        Common01GetVersionCB(const Common01GetVersionRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }

        void respond(const string& arg_version) const {
            cb->dispatch(XrlCmdError::OKAY(),
                         &arg_version);
        }
    };

    struct Common01GetVersionRsp :
      public Common01GetVersionCB {
        struct args_str {
            string version;
        };

    private:
        args_str args;

    public:
        Common01GetVersionRsp(const Common01GetVersionRF& cb)
          : Common01GetVersionCB(cb) { }

        void respond() const {
            Common01GetVersionCB::
            respond(args.version);
        }

        args_str* operator ->() {
            return &args;
        }
    };

    virtual void async_common_0_1_get_version
       (
    Common01GetVersionCB);
#endif

    virtual XrlCmdError common_0_1_get_status(
    // Output values,
    uint32_t&   status,
    string& reason) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback3<void, const XrlCmdError &,
    const uint32_t*,
    const string*>::RefPtr
    Common01GetStatusRF;

    class Common01GetStatusCB {
        Common01GetStatusRF cb;

    public:
        operator const Common01GetStatusRF& () const { return cb; }
        const Common01GetStatusRF& operator ->() const { return cb; }
        Common01GetStatusCB(const Common01GetStatusRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }

        void respond(const uint32_t& arg_status,
                     const string& arg_reason) const {
            cb->dispatch(XrlCmdError::OKAY(),
                         &arg_status,
                         &arg_reason);
        }
    };

    struct Common01GetStatusRsp :
      public Common01GetStatusCB {
        struct args_str {
            uint32_t status;
            string reason;
        };

    private:
        args_str args;

    public:
        Common01GetStatusRsp(const Common01GetStatusRF& cb)
          : Common01GetStatusCB(cb) { }

        void respond() const {
            Common01GetStatusCB::
            respond(args.status,
                        args.reason);
        }

        args_str* operator ->() {
            return &args;
        }
    };

    virtual void async_common_0_1_get_status
       (
    Common01GetStatusCB);
#endif

    virtual XrlCmdError common_0_1_shutdown() = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Common01ShutdownRF;

    class Common01ShutdownCB {
        Common01ShutdownRF cb;

    public:
        operator const Common01ShutdownRF& () const { return cb; }
        const Common01ShutdownRF& operator ->() const { return cb; }
        Common01ShutdownCB(const Common01ShutdownRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct Common01ShutdownRsp :
      public Common01ShutdownCB {
        Common01ShutdownRsp(const Common01ShutdownRF& cb)
          : Common01ShutdownCB(cb) { }

    };

    virtual void async_common_0_1_shutdown
       (
    Common01ShutdownCB);
#endif

    virtual XrlCmdError common_0_1_startup() = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Common01StartupRF;

    class Common01StartupCB {
        Common01StartupRF cb;

    public:
        operator const Common01StartupRF& () const { return cb; }
        const Common01StartupRF& operator ->() const { return cb; }
        Common01StartupCB(const Common01StartupRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct Common01StartupRsp :
      public Common01StartupCB {
        Common01StartupRsp(const Common01StartupRF& cb)
          : Common01StartupCB(cb) { }

    };

    virtual void async_common_0_1_startup
       (
    Common01StartupCB);
#endif

    virtual XrlCmdError test_peer_0_1_register(
    // Input values,
    const string&   coordinator,
    const uint32_t& genid) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01RegisterRF;

    class TestPeer01RegisterCB {
        TestPeer01RegisterRF cb;

    public:
        operator const TestPeer01RegisterRF& () const { return cb; }
        const TestPeer01RegisterRF& operator ->() const { return cb; }
        TestPeer01RegisterCB(const TestPeer01RegisterRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01RegisterRsp :
      public TestPeer01RegisterCB {
        TestPeer01RegisterRsp(const TestPeer01RegisterRF& cb)
          : TestPeer01RegisterCB(cb) { }

    };

    virtual void async_test_peer_0_1_register
       (
    const string&   coordinator,
    const uint32_t& genid,
    TestPeer01RegisterCB);
#endif

    virtual XrlCmdError test_peer_0_1_packetisation(
    // Input values,
    const string&   protocol) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01PacketisationRF;

    class TestPeer01PacketisationCB {
        TestPeer01PacketisationRF cb;

    public:
        operator const TestPeer01PacketisationRF& () const { return cb; }
        const TestPeer01PacketisationRF& operator ->() const { return cb; }
        TestPeer01PacketisationCB(const TestPeer01PacketisationRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01PacketisationRsp :
      public TestPeer01PacketisationCB {
        TestPeer01PacketisationRsp(const TestPeer01PacketisationRF& cb)
          : TestPeer01PacketisationCB(cb) { }

    };

    virtual void async_test_peer_0_1_packetisation
       (
    const string&   protocol,
    TestPeer01PacketisationCB);
#endif

    virtual XrlCmdError test_peer_0_1_use_4byte_asnums(
    // Input values,
    const bool& use) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01Use4ByteAsnumsRF;

    class TestPeer01Use4ByteAsnumsCB {
        TestPeer01Use4ByteAsnumsRF cb;

    public:
        operator const TestPeer01Use4ByteAsnumsRF& () const { return cb; }
        const TestPeer01Use4ByteAsnumsRF& operator ->() const { return cb; }
        TestPeer01Use4ByteAsnumsCB(const TestPeer01Use4ByteAsnumsRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01Use4ByteAsnumsRsp :
      public TestPeer01Use4ByteAsnumsCB {
        TestPeer01Use4ByteAsnumsRsp(const TestPeer01Use4ByteAsnumsRF& cb)
          : TestPeer01Use4ByteAsnumsCB(cb) { }

    };

    virtual void async_test_peer_0_1_use_4byte_asnums
       (
    const bool& use,
    TestPeer01Use4ByteAsnumsCB);
#endif

    virtual XrlCmdError test_peer_0_1_connect(
    // Input values,
    const string&   host,
    const uint32_t& port) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01ConnectRF;

    class TestPeer01ConnectCB {
        TestPeer01ConnectRF cb;

    public:
        operator const TestPeer01ConnectRF& () const { return cb; }
        const TestPeer01ConnectRF& operator ->() const { return cb; }
        TestPeer01ConnectCB(const TestPeer01ConnectRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01ConnectRsp :
      public TestPeer01ConnectCB {
        TestPeer01ConnectRsp(const TestPeer01ConnectRF& cb)
          : TestPeer01ConnectCB(cb) { }

    };

    virtual void async_test_peer_0_1_connect
       (
    const string&   host,
    const uint32_t& port,
    TestPeer01ConnectCB);
#endif

    virtual XrlCmdError test_peer_0_1_listen(
    // Input values,
    const string&   address,
    const uint32_t& port) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01ListenRF;

    class TestPeer01ListenCB {
        TestPeer01ListenRF cb;

    public:
        operator const TestPeer01ListenRF& () const { return cb; }
        const TestPeer01ListenRF& operator ->() const { return cb; }
        TestPeer01ListenCB(const TestPeer01ListenRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01ListenRsp :
      public TestPeer01ListenCB {
        TestPeer01ListenRsp(const TestPeer01ListenRF& cb)
          : TestPeer01ListenCB(cb) { }

    };

    virtual void async_test_peer_0_1_listen
       (
    const string&   address,
    const uint32_t& port,
    TestPeer01ListenCB);
#endif

    virtual XrlCmdError test_peer_0_1_bind(
    // Input values,
    const string&   address,
    const uint32_t& port) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01BindRF;

    class TestPeer01BindCB {
        TestPeer01BindRF cb;

    public:
        operator const TestPeer01BindRF& () const { return cb; }
        const TestPeer01BindRF& operator ->() const { return cb; }
        TestPeer01BindCB(const TestPeer01BindRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01BindRsp :
      public TestPeer01BindCB {
        TestPeer01BindRsp(const TestPeer01BindRF& cb)
          : TestPeer01BindCB(cb) { }

    };

    virtual void async_test_peer_0_1_bind
       (
    const string&   address,
    const uint32_t& port,
    TestPeer01BindCB);
#endif

    virtual XrlCmdError test_peer_0_1_send(
    // Input values,
    const vector<uint8_t>&  data) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01SendRF;

    class TestPeer01SendCB {
        TestPeer01SendRF cb;

    public:
        operator const TestPeer01SendRF& () const { return cb; }
        const TestPeer01SendRF& operator ->() const { return cb; }
        TestPeer01SendCB(const TestPeer01SendRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01SendRsp :
      public TestPeer01SendCB {
        TestPeer01SendRsp(const TestPeer01SendRF& cb)
          : TestPeer01SendCB(cb) { }

    };

    virtual void async_test_peer_0_1_send
       (
    const vector<uint8_t>&  data,
    TestPeer01SendCB);
#endif

    virtual XrlCmdError test_peer_0_1_disconnect() = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01DisconnectRF;

    class TestPeer01DisconnectCB {
        TestPeer01DisconnectRF cb;

    public:
        operator const TestPeer01DisconnectRF& () const { return cb; }
        const TestPeer01DisconnectRF& operator ->() const { return cb; }
        TestPeer01DisconnectCB(const TestPeer01DisconnectRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01DisconnectRsp :
      public TestPeer01DisconnectCB {
        TestPeer01DisconnectRsp(const TestPeer01DisconnectRF& cb)
          : TestPeer01DisconnectCB(cb) { }

    };

    virtual void async_test_peer_0_1_disconnect
       (
    TestPeer01DisconnectCB);
#endif

    virtual XrlCmdError test_peer_0_1_reset() = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01ResetRF;

    class TestPeer01ResetCB {
        TestPeer01ResetRF cb;

    public:
        operator const TestPeer01ResetRF& () const { return cb; }
        const TestPeer01ResetRF& operator ->() const { return cb; }
        TestPeer01ResetCB(const TestPeer01ResetRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01ResetRsp :
      public TestPeer01ResetCB {
        TestPeer01ResetRsp(const TestPeer01ResetRF& cb)
          : TestPeer01ResetCB(cb) { }

    };

    virtual void async_test_peer_0_1_reset
       (
    TestPeer01ResetCB);
#endif

    virtual XrlCmdError test_peer_0_1_terminate() = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    TestPeer01TerminateRF;

    class TestPeer01TerminateCB {
        TestPeer01TerminateRF cb;

    public:
        operator const TestPeer01TerminateRF& () const { return cb; }
        const TestPeer01TerminateRF& operator ->() const { return cb; }
        TestPeer01TerminateCB(const TestPeer01TerminateRF& cb)
          : cb(cb) { }

        void fail(const XrlCmdError &e) const { cb->dispatch(e); }

        void respond() const {
            cb->dispatch(XrlCmdError::OKAY());
        }
    };

    struct TestPeer01TerminateRsp :
      public TestPeer01TerminateCB {
        TestPeer01TerminateRsp(const TestPeer01TerminateRF& cb)
          : TestPeer01TerminateCB(cb) { }

    };

    virtual void async_test_peer_0_1_terminate
       (
    TestPeer01TerminateCB);
#endif

private:
    XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_common_0_1_get_target_name
       (const XrlCmdError &e,
    const string* arg_name,
        XrlRespCallback);
#endif

    XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_common_0_1_get_version
       (const XrlCmdError &e,
    const string* arg_version,
        XrlRespCallback);
#endif

    XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_common_0_1_get_status
       (const XrlCmdError &e,
    const uint32_t* arg_status,
    const string* arg_reason,
        XrlRespCallback);
#endif

    XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_common_0_1_shutdown
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_common_0_1_startup
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_register(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_register
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_packetisation(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_packetisation
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_use_4byte_asnums(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_use_4byte_asnums
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_connect(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_connect
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_listen(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_listen
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_bind(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_bind
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_send(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_send
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_disconnect(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_disconnect
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_reset(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_reset
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    XrlCmdRT handle_test_peer_0_1_terminate(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_test_peer_0_1_terminate
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

    void add_handlers();
    void remove_handlers();

    struct handler_table {
        const char *name;
        XrlCmdRT (XrlTestPeerTargetBase::*method)(const XrlArgs&, XrlCmdOT);
    };

    static const struct handler_table handlers[];
    static const size_t num_handlers;
};

#endif // __XRL_TARGETS_TEST_PEER_BASE_HH__