xorp

test_peer_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/test_peer_base.hh
00003  * vim:set sts=4 ts=8 ft=cpp:
00004  *
00005  * Copyright (c) 2001-2011 XORP, Inc and Others
00006  * See the XORP LICENSE.lgpl file for licensing, conditions, and warranties
00007  * on use.
00008  *
00009  * DO NOT EDIT THIS FILE - IT IS PROGRAMMATICALLY GENERATED
00010  *
00011  * Generated by 'tgt-gen'.
00012  */
00013 
00014 
00015 #ifndef __XRL_TARGETS_TEST_PEER_BASE_HH__
00016 #define __XRL_TARGETS_TEST_PEER_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlTestPeerTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlTestPeerTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlTestPeerTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlTestPeerTargetBase();
00044 
00055     bool set_command_map(XrlCmdMap* cmds);
00056 
00060     const string& get_name() const { return _cmds->name(); }
00061 
00065     const char* version() const { return "test_peer/0.0"; }
00066 
00067 protected:
00068 
00074     virtual XrlCmdError common_0_1_get_target_name(
00075     // Output values,
00076     string& name) = 0;
00077 #ifdef XORP_ENABLE_ASYNC_SERVER
00078     typedef
00079     XorpCallback2<void, const XrlCmdError &,
00080     const string*>::RefPtr
00081     Common01GetTargetNameRF;
00082 
00083     class Common01GetTargetNameCB {
00084         Common01GetTargetNameRF cb;
00085 
00086     public:
00087         operator const Common01GetTargetNameRF& () const { return cb; }
00088         const Common01GetTargetNameRF& operator ->() const { return cb; }
00089         Common01GetTargetNameCB(const Common01GetTargetNameRF& cb)
00090           : cb(cb) { }
00091 
00092         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00093 
00094         void respond(const string& arg_name) const {
00095             cb->dispatch(XrlCmdError::OKAY(),
00096                          &arg_name);
00097         }
00098     };
00099 
00100     struct Common01GetTargetNameRsp :
00101       public Common01GetTargetNameCB {
00102         struct args_str {
00103             string name;
00104         };
00105 
00106     private:
00107         args_str args;
00108 
00109     public:
00110         Common01GetTargetNameRsp(const Common01GetTargetNameRF& cb)
00111           : Common01GetTargetNameCB(cb) { }
00112 
00113         void respond() const {
00114             Common01GetTargetNameCB::
00115             respond(args.name);
00116         }
00117 
00118         args_str* operator ->() {
00119             return &args;
00120         }
00121     };
00122 
00123     virtual void async_common_0_1_get_target_name
00124        (
00125     Common01GetTargetNameCB);
00126 #endif
00127 
00133     virtual XrlCmdError common_0_1_get_version(
00134     // Output values,
00135     string& version) = 0;
00136 #ifdef XORP_ENABLE_ASYNC_SERVER
00137     typedef
00138     XorpCallback2<void, const XrlCmdError &,
00139     const string*>::RefPtr
00140     Common01GetVersionRF;
00141 
00142     class Common01GetVersionCB {
00143         Common01GetVersionRF cb;
00144 
00145     public:
00146         operator const Common01GetVersionRF& () const { return cb; }
00147         const Common01GetVersionRF& operator ->() const { return cb; }
00148         Common01GetVersionCB(const Common01GetVersionRF& cb)
00149           : cb(cb) { }
00150 
00151         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00152 
00153         void respond(const string& arg_version) const {
00154             cb->dispatch(XrlCmdError::OKAY(),
00155                          &arg_version);
00156         }
00157     };
00158 
00159     struct Common01GetVersionRsp :
00160       public Common01GetVersionCB {
00161         struct args_str {
00162             string version;
00163         };
00164 
00165     private:
00166         args_str args;
00167 
00168     public:
00169         Common01GetVersionRsp(const Common01GetVersionRF& cb)
00170           : Common01GetVersionCB(cb) { }
00171 
00172         void respond() const {
00173             Common01GetVersionCB::
00174             respond(args.version);
00175         }
00176 
00177         args_str* operator ->() {
00178             return &args;
00179         }
00180     };
00181 
00182     virtual void async_common_0_1_get_version
00183        (
00184     Common01GetVersionCB);
00185 #endif
00186 
00192     virtual XrlCmdError common_0_1_get_status(
00193     // Output values,
00194     uint32_t&   status,
00195     string& reason) = 0;
00196 #ifdef XORP_ENABLE_ASYNC_SERVER
00197     typedef
00198     XorpCallback3<void, const XrlCmdError &,
00199     const uint32_t*,
00200     const string*>::RefPtr
00201     Common01GetStatusRF;
00202 
00203     class Common01GetStatusCB {
00204         Common01GetStatusRF cb;
00205 
00206     public:
00207         operator const Common01GetStatusRF& () const { return cb; }
00208         const Common01GetStatusRF& operator ->() const { return cb; }
00209         Common01GetStatusCB(const Common01GetStatusRF& cb)
00210           : cb(cb) { }
00211 
00212         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00213 
00214         void respond(const uint32_t& arg_status,
00215                      const string& arg_reason) const {
00216             cb->dispatch(XrlCmdError::OKAY(),
00217                          &arg_status,
00218                          &arg_reason);
00219         }
00220     };
00221 
00222     struct Common01GetStatusRsp :
00223       public Common01GetStatusCB {
00224         struct args_str {
00225             uint32_t status;
00226             string reason;
00227         };
00228 
00229     private:
00230         args_str args;
00231 
00232     public:
00233         Common01GetStatusRsp(const Common01GetStatusRF& cb)
00234           : Common01GetStatusCB(cb) { }
00235 
00236         void respond() const {
00237             Common01GetStatusCB::
00238             respond(args.status,
00239                         args.reason);
00240         }
00241 
00242         args_str* operator ->() {
00243             return &args;
00244         }
00245     };
00246 
00247     virtual void async_common_0_1_get_status
00248        (
00249     Common01GetStatusCB);
00250 #endif
00251 
00257     virtual XrlCmdError common_0_1_shutdown() = 0;
00258 #ifdef XORP_ENABLE_ASYNC_SERVER
00259     typedef
00260     XorpCallback1<void, const XrlCmdError &>::RefPtr
00261     Common01ShutdownRF;
00262 
00263     class Common01ShutdownCB {
00264         Common01ShutdownRF cb;
00265 
00266     public:
00267         operator const Common01ShutdownRF& () const { return cb; }
00268         const Common01ShutdownRF& operator ->() const { return cb; }
00269         Common01ShutdownCB(const Common01ShutdownRF& cb)
00270           : cb(cb) { }
00271 
00272         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00273 
00274         void respond() const {
00275             cb->dispatch(XrlCmdError::OKAY());
00276         }
00277     };
00278 
00279     struct Common01ShutdownRsp :
00280       public Common01ShutdownCB {
00281         Common01ShutdownRsp(const Common01ShutdownRF& cb)
00282           : Common01ShutdownCB(cb) { }
00283 
00284     };
00285 
00286     virtual void async_common_0_1_shutdown
00287        (
00288     Common01ShutdownCB);
00289 #endif
00290 
00296     virtual XrlCmdError common_0_1_startup() = 0;
00297 #ifdef XORP_ENABLE_ASYNC_SERVER
00298     typedef
00299     XorpCallback1<void, const XrlCmdError &>::RefPtr
00300     Common01StartupRF;
00301 
00302     class Common01StartupCB {
00303         Common01StartupRF cb;
00304 
00305     public:
00306         operator const Common01StartupRF& () const { return cb; }
00307         const Common01StartupRF& operator ->() const { return cb; }
00308         Common01StartupCB(const Common01StartupRF& cb)
00309           : cb(cb) { }
00310 
00311         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00312 
00313         void respond() const {
00314             cb->dispatch(XrlCmdError::OKAY());
00315         }
00316     };
00317 
00318     struct Common01StartupRsp :
00319       public Common01StartupCB {
00320         Common01StartupRsp(const Common01StartupRF& cb)
00321           : Common01StartupCB(cb) { }
00322 
00323     };
00324 
00325     virtual void async_common_0_1_startup
00326        (
00327     Common01StartupCB);
00328 #endif
00329 
00338     virtual XrlCmdError test_peer_0_1_register(
00339     // Input values,
00340     const string&   coordinator,
00341     const uint32_t& genid) = 0;
00342 #ifdef XORP_ENABLE_ASYNC_SERVER
00343     typedef
00344     XorpCallback1<void, const XrlCmdError &>::RefPtr
00345     TestPeer01RegisterRF;
00346 
00347     class TestPeer01RegisterCB {
00348         TestPeer01RegisterRF cb;
00349 
00350     public:
00351         operator const TestPeer01RegisterRF& () const { return cb; }
00352         const TestPeer01RegisterRF& operator ->() const { return cb; }
00353         TestPeer01RegisterCB(const TestPeer01RegisterRF& cb)
00354           : cb(cb) { }
00355 
00356         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00357 
00358         void respond() const {
00359             cb->dispatch(XrlCmdError::OKAY());
00360         }
00361     };
00362 
00363     struct TestPeer01RegisterRsp :
00364       public TestPeer01RegisterCB {
00365         TestPeer01RegisterRsp(const TestPeer01RegisterRF& cb)
00366           : TestPeer01RegisterCB(cb) { }
00367 
00368     };
00369 
00370     virtual void async_test_peer_0_1_register
00371        (
00372     const string&   coordinator,
00373     const uint32_t& genid,
00374     TestPeer01RegisterCB);
00375 #endif
00376 
00382     virtual XrlCmdError test_peer_0_1_packetisation(
00383     // Input values,
00384     const string&   protocol) = 0;
00385 #ifdef XORP_ENABLE_ASYNC_SERVER
00386     typedef
00387     XorpCallback1<void, const XrlCmdError &>::RefPtr
00388     TestPeer01PacketisationRF;
00389 
00390     class TestPeer01PacketisationCB {
00391         TestPeer01PacketisationRF cb;
00392 
00393     public:
00394         operator const TestPeer01PacketisationRF& () const { return cb; }
00395         const TestPeer01PacketisationRF& operator ->() const { return cb; }
00396         TestPeer01PacketisationCB(const TestPeer01PacketisationRF& cb)
00397           : cb(cb) { }
00398 
00399         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00400 
00401         void respond() const {
00402             cb->dispatch(XrlCmdError::OKAY());
00403         }
00404     };
00405 
00406     struct TestPeer01PacketisationRsp :
00407       public TestPeer01PacketisationCB {
00408         TestPeer01PacketisationRsp(const TestPeer01PacketisationRF& cb)
00409           : TestPeer01PacketisationCB(cb) { }
00410 
00411     };
00412 
00413     virtual void async_test_peer_0_1_packetisation
00414        (
00415     const string&   protocol,
00416     TestPeer01PacketisationCB);
00417 #endif
00418 
00424     virtual XrlCmdError test_peer_0_1_use_4byte_asnums(
00425     // Input values,
00426     const bool& use) = 0;
00427 #ifdef XORP_ENABLE_ASYNC_SERVER
00428     typedef
00429     XorpCallback1<void, const XrlCmdError &>::RefPtr
00430     TestPeer01Use4ByteAsnumsRF;
00431 
00432     class TestPeer01Use4ByteAsnumsCB {
00433         TestPeer01Use4ByteAsnumsRF cb;
00434 
00435     public:
00436         operator const TestPeer01Use4ByteAsnumsRF& () const { return cb; }
00437         const TestPeer01Use4ByteAsnumsRF& operator ->() const { return cb; }
00438         TestPeer01Use4ByteAsnumsCB(const TestPeer01Use4ByteAsnumsRF& cb)
00439           : cb(cb) { }
00440 
00441         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00442 
00443         void respond() const {
00444             cb->dispatch(XrlCmdError::OKAY());
00445         }
00446     };
00447 
00448     struct TestPeer01Use4ByteAsnumsRsp :
00449       public TestPeer01Use4ByteAsnumsCB {
00450         TestPeer01Use4ByteAsnumsRsp(const TestPeer01Use4ByteAsnumsRF& cb)
00451           : TestPeer01Use4ByteAsnumsCB(cb) { }
00452 
00453     };
00454 
00455     virtual void async_test_peer_0_1_use_4byte_asnums
00456        (
00457     const bool& use,
00458     TestPeer01Use4ByteAsnumsCB);
00459 #endif
00460 
00470     virtual XrlCmdError test_peer_0_1_connect(
00471     // Input values,
00472     const string&   host,
00473     const uint32_t& port) = 0;
00474 #ifdef XORP_ENABLE_ASYNC_SERVER
00475     typedef
00476     XorpCallback1<void, const XrlCmdError &>::RefPtr
00477     TestPeer01ConnectRF;
00478 
00479     class TestPeer01ConnectCB {
00480         TestPeer01ConnectRF cb;
00481 
00482     public:
00483         operator const TestPeer01ConnectRF& () const { return cb; }
00484         const TestPeer01ConnectRF& operator ->() const { return cb; }
00485         TestPeer01ConnectCB(const TestPeer01ConnectRF& cb)
00486           : cb(cb) { }
00487 
00488         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00489 
00490         void respond() const {
00491             cb->dispatch(XrlCmdError::OKAY());
00492         }
00493     };
00494 
00495     struct TestPeer01ConnectRsp :
00496       public TestPeer01ConnectCB {
00497         TestPeer01ConnectRsp(const TestPeer01ConnectRF& cb)
00498           : TestPeer01ConnectCB(cb) { }
00499 
00500     };
00501 
00502     virtual void async_test_peer_0_1_connect
00503        (
00504     const string&   host,
00505     const uint32_t& port,
00506     TestPeer01ConnectCB);
00507 #endif
00508 
00518     virtual XrlCmdError test_peer_0_1_listen(
00519     // Input values,
00520     const string&   address,
00521     const uint32_t& port) = 0;
00522 #ifdef XORP_ENABLE_ASYNC_SERVER
00523     typedef
00524     XorpCallback1<void, const XrlCmdError &>::RefPtr
00525     TestPeer01ListenRF;
00526 
00527     class TestPeer01ListenCB {
00528         TestPeer01ListenRF cb;
00529 
00530     public:
00531         operator const TestPeer01ListenRF& () const { return cb; }
00532         const TestPeer01ListenRF& operator ->() const { return cb; }
00533         TestPeer01ListenCB(const TestPeer01ListenRF& cb)
00534           : cb(cb) { }
00535 
00536         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00537 
00538         void respond() const {
00539             cb->dispatch(XrlCmdError::OKAY());
00540         }
00541     };
00542 
00543     struct TestPeer01ListenRsp :
00544       public TestPeer01ListenCB {
00545         TestPeer01ListenRsp(const TestPeer01ListenRF& cb)
00546           : TestPeer01ListenCB(cb) { }
00547 
00548     };
00549 
00550     virtual void async_test_peer_0_1_listen
00551        (
00552     const string&   address,
00553     const uint32_t& port,
00554     TestPeer01ListenCB);
00555 #endif
00556 
00566     virtual XrlCmdError test_peer_0_1_bind(
00567     // Input values,
00568     const string&   address,
00569     const uint32_t& port) = 0;
00570 #ifdef XORP_ENABLE_ASYNC_SERVER
00571     typedef
00572     XorpCallback1<void, const XrlCmdError &>::RefPtr
00573     TestPeer01BindRF;
00574 
00575     class TestPeer01BindCB {
00576         TestPeer01BindRF cb;
00577 
00578     public:
00579         operator const TestPeer01BindRF& () const { return cb; }
00580         const TestPeer01BindRF& operator ->() const { return cb; }
00581         TestPeer01BindCB(const TestPeer01BindRF& cb)
00582           : cb(cb) { }
00583 
00584         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00585 
00586         void respond() const {
00587             cb->dispatch(XrlCmdError::OKAY());
00588         }
00589     };
00590 
00591     struct TestPeer01BindRsp :
00592       public TestPeer01BindCB {
00593         TestPeer01BindRsp(const TestPeer01BindRF& cb)
00594           : TestPeer01BindCB(cb) { }
00595 
00596     };
00597 
00598     virtual void async_test_peer_0_1_bind
00599        (
00600     const string&   address,
00601     const uint32_t& port,
00602     TestPeer01BindCB);
00603 #endif
00604 
00610     virtual XrlCmdError test_peer_0_1_send(
00611     // Input values,
00612     const vector<uint8_t>&  data) = 0;
00613 #ifdef XORP_ENABLE_ASYNC_SERVER
00614     typedef
00615     XorpCallback1<void, const XrlCmdError &>::RefPtr
00616     TestPeer01SendRF;
00617 
00618     class TestPeer01SendCB {
00619         TestPeer01SendRF cb;
00620 
00621     public:
00622         operator const TestPeer01SendRF& () const { return cb; }
00623         const TestPeer01SendRF& operator ->() const { return cb; }
00624         TestPeer01SendCB(const TestPeer01SendRF& cb)
00625           : cb(cb) { }
00626 
00627         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00628 
00629         void respond() const {
00630             cb->dispatch(XrlCmdError::OKAY());
00631         }
00632     };
00633 
00634     struct TestPeer01SendRsp :
00635       public TestPeer01SendCB {
00636         TestPeer01SendRsp(const TestPeer01SendRF& cb)
00637           : TestPeer01SendCB(cb) { }
00638 
00639     };
00640 
00641     virtual void async_test_peer_0_1_send
00642        (
00643     const vector<uint8_t>&  data,
00644     TestPeer01SendCB);
00645 #endif
00646 
00652     virtual XrlCmdError test_peer_0_1_disconnect() = 0;
00653 #ifdef XORP_ENABLE_ASYNC_SERVER
00654     typedef
00655     XorpCallback1<void, const XrlCmdError &>::RefPtr
00656     TestPeer01DisconnectRF;
00657 
00658     class TestPeer01DisconnectCB {
00659         TestPeer01DisconnectRF cb;
00660 
00661     public:
00662         operator const TestPeer01DisconnectRF& () const { return cb; }
00663         const TestPeer01DisconnectRF& operator ->() const { return cb; }
00664         TestPeer01DisconnectCB(const TestPeer01DisconnectRF& cb)
00665           : cb(cb) { }
00666 
00667         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00668 
00669         void respond() const {
00670             cb->dispatch(XrlCmdError::OKAY());
00671         }
00672     };
00673 
00674     struct TestPeer01DisconnectRsp :
00675       public TestPeer01DisconnectCB {
00676         TestPeer01DisconnectRsp(const TestPeer01DisconnectRF& cb)
00677           : TestPeer01DisconnectCB(cb) { }
00678 
00679     };
00680 
00681     virtual void async_test_peer_0_1_disconnect
00682        (
00683     TestPeer01DisconnectCB);
00684 #endif
00685 
00691     virtual XrlCmdError test_peer_0_1_reset() = 0;
00692 #ifdef XORP_ENABLE_ASYNC_SERVER
00693     typedef
00694     XorpCallback1<void, const XrlCmdError &>::RefPtr
00695     TestPeer01ResetRF;
00696 
00697     class TestPeer01ResetCB {
00698         TestPeer01ResetRF cb;
00699 
00700     public:
00701         operator const TestPeer01ResetRF& () const { return cb; }
00702         const TestPeer01ResetRF& operator ->() const { return cb; }
00703         TestPeer01ResetCB(const TestPeer01ResetRF& cb)
00704           : cb(cb) { }
00705 
00706         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00707 
00708         void respond() const {
00709             cb->dispatch(XrlCmdError::OKAY());
00710         }
00711     };
00712 
00713     struct TestPeer01ResetRsp :
00714       public TestPeer01ResetCB {
00715         TestPeer01ResetRsp(const TestPeer01ResetRF& cb)
00716           : TestPeer01ResetCB(cb) { }
00717 
00718     };
00719 
00720     virtual void async_test_peer_0_1_reset
00721        (
00722     TestPeer01ResetCB);
00723 #endif
00724 
00730     virtual XrlCmdError test_peer_0_1_terminate() = 0;
00731 #ifdef XORP_ENABLE_ASYNC_SERVER
00732     typedef
00733     XorpCallback1<void, const XrlCmdError &>::RefPtr
00734     TestPeer01TerminateRF;
00735 
00736     class TestPeer01TerminateCB {
00737         TestPeer01TerminateRF cb;
00738 
00739     public:
00740         operator const TestPeer01TerminateRF& () const { return cb; }
00741         const TestPeer01TerminateRF& operator ->() const { return cb; }
00742         TestPeer01TerminateCB(const TestPeer01TerminateRF& cb)
00743           : cb(cb) { }
00744 
00745         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00746 
00747         void respond() const {
00748             cb->dispatch(XrlCmdError::OKAY());
00749         }
00750     };
00751 
00752     struct TestPeer01TerminateRsp :
00753       public TestPeer01TerminateCB {
00754         TestPeer01TerminateRsp(const TestPeer01TerminateRF& cb)
00755           : TestPeer01TerminateCB(cb) { }
00756 
00757     };
00758 
00759     virtual void async_test_peer_0_1_terminate
00760        (
00761     TestPeer01TerminateCB);
00762 #endif
00763 
00764 private:
00765     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
00766 #ifdef XORP_ENABLE_ASYNC_SERVER
00767     void callback_common_0_1_get_target_name
00768        (const XrlCmdError &e,
00769     const string* arg_name,
00770         XrlRespCallback);
00771 #endif
00772 
00773     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
00774 #ifdef XORP_ENABLE_ASYNC_SERVER
00775     void callback_common_0_1_get_version
00776        (const XrlCmdError &e,
00777     const string* arg_version,
00778         XrlRespCallback);
00779 #endif
00780 
00781     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
00782 #ifdef XORP_ENABLE_ASYNC_SERVER
00783     void callback_common_0_1_get_status
00784        (const XrlCmdError &e,
00785     const uint32_t* arg_status,
00786     const string* arg_reason,
00787         XrlRespCallback);
00788 #endif
00789 
00790     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
00791 #ifdef XORP_ENABLE_ASYNC_SERVER
00792     void callback_common_0_1_shutdown
00793        (const XrlCmdError &e,
00794         XrlRespCallback);
00795 #endif
00796 
00797     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
00798 #ifdef XORP_ENABLE_ASYNC_SERVER
00799     void callback_common_0_1_startup
00800        (const XrlCmdError &e,
00801         XrlRespCallback);
00802 #endif
00803 
00804     XrlCmdRT handle_test_peer_0_1_register(const XrlArgs& in, XrlCmdOT out);
00805 #ifdef XORP_ENABLE_ASYNC_SERVER
00806     void callback_test_peer_0_1_register
00807        (const XrlCmdError &e,
00808         XrlRespCallback);
00809 #endif
00810 
00811     XrlCmdRT handle_test_peer_0_1_packetisation(const XrlArgs& in, XrlCmdOT out);
00812 #ifdef XORP_ENABLE_ASYNC_SERVER
00813     void callback_test_peer_0_1_packetisation
00814        (const XrlCmdError &e,
00815         XrlRespCallback);
00816 #endif
00817 
00818     XrlCmdRT handle_test_peer_0_1_use_4byte_asnums(const XrlArgs& in, XrlCmdOT out);
00819 #ifdef XORP_ENABLE_ASYNC_SERVER
00820     void callback_test_peer_0_1_use_4byte_asnums
00821        (const XrlCmdError &e,
00822         XrlRespCallback);
00823 #endif
00824 
00825     XrlCmdRT handle_test_peer_0_1_connect(const XrlArgs& in, XrlCmdOT out);
00826 #ifdef XORP_ENABLE_ASYNC_SERVER
00827     void callback_test_peer_0_1_connect
00828        (const XrlCmdError &e,
00829         XrlRespCallback);
00830 #endif
00831 
00832     XrlCmdRT handle_test_peer_0_1_listen(const XrlArgs& in, XrlCmdOT out);
00833 #ifdef XORP_ENABLE_ASYNC_SERVER
00834     void callback_test_peer_0_1_listen
00835        (const XrlCmdError &e,
00836         XrlRespCallback);
00837 #endif
00838 
00839     XrlCmdRT handle_test_peer_0_1_bind(const XrlArgs& in, XrlCmdOT out);
00840 #ifdef XORP_ENABLE_ASYNC_SERVER
00841     void callback_test_peer_0_1_bind
00842        (const XrlCmdError &e,
00843         XrlRespCallback);
00844 #endif
00845 
00846     XrlCmdRT handle_test_peer_0_1_send(const XrlArgs& in, XrlCmdOT out);
00847 #ifdef XORP_ENABLE_ASYNC_SERVER
00848     void callback_test_peer_0_1_send
00849        (const XrlCmdError &e,
00850         XrlRespCallback);
00851 #endif
00852 
00853     XrlCmdRT handle_test_peer_0_1_disconnect(const XrlArgs& in, XrlCmdOT out);
00854 #ifdef XORP_ENABLE_ASYNC_SERVER
00855     void callback_test_peer_0_1_disconnect
00856        (const XrlCmdError &e,
00857         XrlRespCallback);
00858 #endif
00859 
00860     XrlCmdRT handle_test_peer_0_1_reset(const XrlArgs& in, XrlCmdOT out);
00861 #ifdef XORP_ENABLE_ASYNC_SERVER
00862     void callback_test_peer_0_1_reset
00863        (const XrlCmdError &e,
00864         XrlRespCallback);
00865 #endif
00866 
00867     XrlCmdRT handle_test_peer_0_1_terminate(const XrlArgs& in, XrlCmdOT out);
00868 #ifdef XORP_ENABLE_ASYNC_SERVER
00869     void callback_test_peer_0_1_terminate
00870        (const XrlCmdError &e,
00871         XrlRespCallback);
00872 #endif
00873 
00874     void add_handlers();
00875     void remove_handlers();
00876 
00877     struct handler_table {
00878         const char *name;
00879         XrlCmdRT (XrlTestPeerTargetBase::*method)(const XrlArgs&, XrlCmdOT);
00880     };
00881 
00882     static const struct handler_table handlers[];
00883     static const size_t num_handlers;
00884 };
00885 
00886 #endif // __XRL_TARGETS_TEST_PEER_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations