xorp

rtrmgr_base.hh

00001 /*
00002  * obj/i686-pc-linux-gnu/xrl/targets/rtrmgr_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_RTRMGR_BASE_HH__
00016 #define __XRL_TARGETS_RTRMGR_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlRtrmgrTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlRtrmgrTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlRtrmgrTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlRtrmgrTargetBase();
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 "rtrmgr/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 
00330     virtual XrlCmdError rtrmgr_0_1_get_pid(
00331     // Output values,
00332     uint32_t&   pid) = 0;
00333 #ifdef XORP_ENABLE_ASYNC_SERVER
00334     typedef
00335     XorpCallback2<void, const XrlCmdError &,
00336     const uint32_t*>::RefPtr
00337     Rtrmgr01GetPidRF;
00338 
00339     class Rtrmgr01GetPidCB {
00340         Rtrmgr01GetPidRF cb;
00341 
00342     public:
00343         operator const Rtrmgr01GetPidRF& () const { return cb; }
00344         const Rtrmgr01GetPidRF& operator ->() const { return cb; }
00345         Rtrmgr01GetPidCB(const Rtrmgr01GetPidRF& cb)
00346           : cb(cb) { }
00347 
00348         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00349 
00350         void respond(const uint32_t& arg_pid) const {
00351             cb->dispatch(XrlCmdError::OKAY(),
00352                          &arg_pid);
00353         }
00354     };
00355 
00356     struct Rtrmgr01GetPidRsp :
00357       public Rtrmgr01GetPidCB {
00358         struct args_str {
00359             uint32_t pid;
00360         };
00361 
00362     private:
00363         args_str args;
00364 
00365     public:
00366         Rtrmgr01GetPidRsp(const Rtrmgr01GetPidRF& cb)
00367           : Rtrmgr01GetPidCB(cb) { }
00368 
00369         void respond() const {
00370             Rtrmgr01GetPidCB::
00371             respond(args.pid);
00372         }
00373 
00374         args_str* operator ->() {
00375             return &args;
00376         }
00377     };
00378 
00379     virtual void async_rtrmgr_0_1_get_pid
00380        (
00381     Rtrmgr01GetPidCB);
00382 #endif
00383 
00392     virtual XrlCmdError rtrmgr_0_1_register_client(
00393     // Input values,
00394     const uint32_t& userid,
00395     const string&   clientname,
00396     // Output values,
00397     string& filename,
00398     uint32_t&   pid,
00399     uint32_t&   clientid) = 0;
00400 #ifdef XORP_ENABLE_ASYNC_SERVER
00401     typedef
00402     XorpCallback4<void, const XrlCmdError &,
00403     const string*,
00404     const uint32_t*,
00405     const uint32_t*>::RefPtr
00406     Rtrmgr01RegisterClientRF;
00407 
00408     class Rtrmgr01RegisterClientCB {
00409         Rtrmgr01RegisterClientRF cb;
00410 
00411     public:
00412         operator const Rtrmgr01RegisterClientRF& () const { return cb; }
00413         const Rtrmgr01RegisterClientRF& operator ->() const { return cb; }
00414         Rtrmgr01RegisterClientCB(const Rtrmgr01RegisterClientRF& cb)
00415           : cb(cb) { }
00416 
00417         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL); }
00418 
00419         void respond(const string& arg_filename,
00420                      const uint32_t& arg_pid,
00421                      const uint32_t& arg_clientid) const {
00422             cb->dispatch(XrlCmdError::OKAY(),
00423                          &arg_filename,
00424                          &arg_pid,
00425                          &arg_clientid);
00426         }
00427     };
00428 
00429     struct Rtrmgr01RegisterClientRsp :
00430       public Rtrmgr01RegisterClientCB {
00431         struct args_str {
00432             string filename;
00433             uint32_t pid;
00434             uint32_t clientid;
00435         };
00436 
00437     private:
00438         args_str args;
00439 
00440     public:
00441         Rtrmgr01RegisterClientRsp(const Rtrmgr01RegisterClientRF& cb)
00442           : Rtrmgr01RegisterClientCB(cb) { }
00443 
00444         void respond() const {
00445             Rtrmgr01RegisterClientCB::
00446             respond(args.filename,
00447                         args.pid,
00448                         args.clientid);
00449         }
00450 
00451         args_str* operator ->() {
00452             return &args;
00453         }
00454     };
00455 
00456     virtual void async_rtrmgr_0_1_register_client
00457        (
00458     const uint32_t& userid,
00459     const string&   clientname,
00460     Rtrmgr01RegisterClientCB);
00461 #endif
00462 
00463     virtual XrlCmdError rtrmgr_0_1_unregister_client(
00464     // Input values,
00465     const string&   token) = 0;
00466 #ifdef XORP_ENABLE_ASYNC_SERVER
00467     typedef
00468     XorpCallback1<void, const XrlCmdError &>::RefPtr
00469     Rtrmgr01UnregisterClientRF;
00470 
00471     class Rtrmgr01UnregisterClientCB {
00472         Rtrmgr01UnregisterClientRF cb;
00473 
00474     public:
00475         operator const Rtrmgr01UnregisterClientRF& () const { return cb; }
00476         const Rtrmgr01UnregisterClientRF& operator ->() const { return cb; }
00477         Rtrmgr01UnregisterClientCB(const Rtrmgr01UnregisterClientRF& cb)
00478           : cb(cb) { }
00479 
00480         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00481 
00482         void respond() const {
00483             cb->dispatch(XrlCmdError::OKAY());
00484         }
00485     };
00486 
00487     struct Rtrmgr01UnregisterClientRsp :
00488       public Rtrmgr01UnregisterClientCB {
00489         Rtrmgr01UnregisterClientRsp(const Rtrmgr01UnregisterClientRF& cb)
00490           : Rtrmgr01UnregisterClientCB(cb) { }
00491 
00492     };
00493 
00494     virtual void async_rtrmgr_0_1_unregister_client
00495        (
00496     const string&   token,
00497     Rtrmgr01UnregisterClientCB);
00498 #endif
00499 
00500     virtual XrlCmdError rtrmgr_0_1_authenticate_client(
00501     // Input values,
00502     const uint32_t& userid,
00503     const string&   clientname,
00504     const string&   token) = 0;
00505 #ifdef XORP_ENABLE_ASYNC_SERVER
00506     typedef
00507     XorpCallback1<void, const XrlCmdError &>::RefPtr
00508     Rtrmgr01AuthenticateClientRF;
00509 
00510     class Rtrmgr01AuthenticateClientCB {
00511         Rtrmgr01AuthenticateClientRF cb;
00512 
00513     public:
00514         operator const Rtrmgr01AuthenticateClientRF& () const { return cb; }
00515         const Rtrmgr01AuthenticateClientRF& operator ->() const { return cb; }
00516         Rtrmgr01AuthenticateClientCB(const Rtrmgr01AuthenticateClientRF& cb)
00517           : cb(cb) { }
00518 
00519         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00520 
00521         void respond() const {
00522             cb->dispatch(XrlCmdError::OKAY());
00523         }
00524     };
00525 
00526     struct Rtrmgr01AuthenticateClientRsp :
00527       public Rtrmgr01AuthenticateClientCB {
00528         Rtrmgr01AuthenticateClientRsp(const Rtrmgr01AuthenticateClientRF& cb)
00529           : Rtrmgr01AuthenticateClientCB(cb) { }
00530 
00531     };
00532 
00533     virtual void async_rtrmgr_0_1_authenticate_client
00534        (
00535     const uint32_t& userid,
00536     const string&   clientname,
00537     const string&   token,
00538     Rtrmgr01AuthenticateClientCB);
00539 #endif
00540 
00541     virtual XrlCmdError rtrmgr_0_1_enter_config_mode(
00542     // Input values,
00543     const string&   token,
00544     const bool& exclusive) = 0;
00545 #ifdef XORP_ENABLE_ASYNC_SERVER
00546     typedef
00547     XorpCallback1<void, const XrlCmdError &>::RefPtr
00548     Rtrmgr01EnterConfigModeRF;
00549 
00550     class Rtrmgr01EnterConfigModeCB {
00551         Rtrmgr01EnterConfigModeRF cb;
00552 
00553     public:
00554         operator const Rtrmgr01EnterConfigModeRF& () const { return cb; }
00555         const Rtrmgr01EnterConfigModeRF& operator ->() const { return cb; }
00556         Rtrmgr01EnterConfigModeCB(const Rtrmgr01EnterConfigModeRF& cb)
00557           : cb(cb) { }
00558 
00559         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00560 
00561         void respond() const {
00562             cb->dispatch(XrlCmdError::OKAY());
00563         }
00564     };
00565 
00566     struct Rtrmgr01EnterConfigModeRsp :
00567       public Rtrmgr01EnterConfigModeCB {
00568         Rtrmgr01EnterConfigModeRsp(const Rtrmgr01EnterConfigModeRF& cb)
00569           : Rtrmgr01EnterConfigModeCB(cb) { }
00570 
00571     };
00572 
00573     virtual void async_rtrmgr_0_1_enter_config_mode
00574        (
00575     const string&   token,
00576     const bool& exclusive,
00577     Rtrmgr01EnterConfigModeCB);
00578 #endif
00579 
00580     virtual XrlCmdError rtrmgr_0_1_leave_config_mode(
00581     // Input values,
00582     const string&   token) = 0;
00583 #ifdef XORP_ENABLE_ASYNC_SERVER
00584     typedef
00585     XorpCallback1<void, const XrlCmdError &>::RefPtr
00586     Rtrmgr01LeaveConfigModeRF;
00587 
00588     class Rtrmgr01LeaveConfigModeCB {
00589         Rtrmgr01LeaveConfigModeRF cb;
00590 
00591     public:
00592         operator const Rtrmgr01LeaveConfigModeRF& () const { return cb; }
00593         const Rtrmgr01LeaveConfigModeRF& operator ->() const { return cb; }
00594         Rtrmgr01LeaveConfigModeCB(const Rtrmgr01LeaveConfigModeRF& cb)
00595           : cb(cb) { }
00596 
00597         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00598 
00599         void respond() const {
00600             cb->dispatch(XrlCmdError::OKAY());
00601         }
00602     };
00603 
00604     struct Rtrmgr01LeaveConfigModeRsp :
00605       public Rtrmgr01LeaveConfigModeCB {
00606         Rtrmgr01LeaveConfigModeRsp(const Rtrmgr01LeaveConfigModeRF& cb)
00607           : Rtrmgr01LeaveConfigModeCB(cb) { }
00608 
00609     };
00610 
00611     virtual void async_rtrmgr_0_1_leave_config_mode
00612        (
00613     const string&   token,
00614     Rtrmgr01LeaveConfigModeCB);
00615 #endif
00616 
00617     virtual XrlCmdError rtrmgr_0_1_get_config_users(
00618     // Input values,
00619     const string&   token,
00620     // Output values,
00621     XrlAtomList&    users) = 0;
00622 #ifdef XORP_ENABLE_ASYNC_SERVER
00623     typedef
00624     XorpCallback2<void, const XrlCmdError &,
00625     const XrlAtomList*>::RefPtr
00626     Rtrmgr01GetConfigUsersRF;
00627 
00628     class Rtrmgr01GetConfigUsersCB {
00629         Rtrmgr01GetConfigUsersRF cb;
00630 
00631     public:
00632         operator const Rtrmgr01GetConfigUsersRF& () const { return cb; }
00633         const Rtrmgr01GetConfigUsersRF& operator ->() const { return cb; }
00634         Rtrmgr01GetConfigUsersCB(const Rtrmgr01GetConfigUsersRF& cb)
00635           : cb(cb) { }
00636 
00637         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00638 
00639         void respond(const XrlAtomList& arg_users) const {
00640             cb->dispatch(XrlCmdError::OKAY(),
00641                          &arg_users);
00642         }
00643     };
00644 
00645     struct Rtrmgr01GetConfigUsersRsp :
00646       public Rtrmgr01GetConfigUsersCB {
00647         struct args_str {
00648             XrlAtomList users;
00649         };
00650 
00651     private:
00652         args_str args;
00653 
00654     public:
00655         Rtrmgr01GetConfigUsersRsp(const Rtrmgr01GetConfigUsersRF& cb)
00656           : Rtrmgr01GetConfigUsersCB(cb) { }
00657 
00658         void respond() const {
00659             Rtrmgr01GetConfigUsersCB::
00660             respond(args.users);
00661         }
00662 
00663         args_str* operator ->() {
00664             return &args;
00665         }
00666     };
00667 
00668     virtual void async_rtrmgr_0_1_get_config_users
00669        (
00670     const string&   token,
00671     Rtrmgr01GetConfigUsersCB);
00672 #endif
00673 
00674     virtual XrlCmdError rtrmgr_0_1_get_running_config(
00675     // Input values,
00676     const string&   token,
00677     // Output values,
00678     bool&   ready,
00679     string& config) = 0;
00680 #ifdef XORP_ENABLE_ASYNC_SERVER
00681     typedef
00682     XorpCallback3<void, const XrlCmdError &,
00683     const bool*,
00684     const string*>::RefPtr
00685     Rtrmgr01GetRunningConfigRF;
00686 
00687     class Rtrmgr01GetRunningConfigCB {
00688         Rtrmgr01GetRunningConfigRF cb;
00689 
00690     public:
00691         operator const Rtrmgr01GetRunningConfigRF& () const { return cb; }
00692         const Rtrmgr01GetRunningConfigRF& operator ->() const { return cb; }
00693         Rtrmgr01GetRunningConfigCB(const Rtrmgr01GetRunningConfigRF& cb)
00694           : cb(cb) { }
00695 
00696         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00697 
00698         void respond(const bool& arg_ready,
00699                      const string& arg_config) const {
00700             cb->dispatch(XrlCmdError::OKAY(),
00701                          &arg_ready,
00702                          &arg_config);
00703         }
00704     };
00705 
00706     struct Rtrmgr01GetRunningConfigRsp :
00707       public Rtrmgr01GetRunningConfigCB {
00708         struct args_str {
00709             bool ready;
00710             string config;
00711         };
00712 
00713     private:
00714         args_str args;
00715 
00716     public:
00717         Rtrmgr01GetRunningConfigRsp(const Rtrmgr01GetRunningConfigRF& cb)
00718           : Rtrmgr01GetRunningConfigCB(cb) { }
00719 
00720         void respond() const {
00721             Rtrmgr01GetRunningConfigCB::
00722             respond(args.ready,
00723                         args.config);
00724         }
00725 
00726         args_str* operator ->() {
00727             return &args;
00728         }
00729     };
00730 
00731     virtual void async_rtrmgr_0_1_get_running_config
00732        (
00733     const string&   token,
00734     Rtrmgr01GetRunningConfigCB);
00735 #endif
00736 
00737     virtual XrlCmdError rtrmgr_0_1_apply_config_change(
00738     // Input values,
00739     const string&   token,
00740     const string&   target,
00741     const string&   deltas,
00742     const string&   deletions) = 0;
00743 #ifdef XORP_ENABLE_ASYNC_SERVER
00744     typedef
00745     XorpCallback1<void, const XrlCmdError &>::RefPtr
00746     Rtrmgr01ApplyConfigChangeRF;
00747 
00748     class Rtrmgr01ApplyConfigChangeCB {
00749         Rtrmgr01ApplyConfigChangeRF cb;
00750 
00751     public:
00752         operator const Rtrmgr01ApplyConfigChangeRF& () const { return cb; }
00753         const Rtrmgr01ApplyConfigChangeRF& operator ->() const { return cb; }
00754         Rtrmgr01ApplyConfigChangeCB(const Rtrmgr01ApplyConfigChangeRF& cb)
00755           : cb(cb) { }
00756 
00757         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00758 
00759         void respond() const {
00760             cb->dispatch(XrlCmdError::OKAY());
00761         }
00762     };
00763 
00764     struct Rtrmgr01ApplyConfigChangeRsp :
00765       public Rtrmgr01ApplyConfigChangeCB {
00766         Rtrmgr01ApplyConfigChangeRsp(const Rtrmgr01ApplyConfigChangeRF& cb)
00767           : Rtrmgr01ApplyConfigChangeCB(cb) { }
00768 
00769     };
00770 
00771     virtual void async_rtrmgr_0_1_apply_config_change
00772        (
00773     const string&   token,
00774     const string&   target,
00775     const string&   deltas,
00776     const string&   deletions,
00777     Rtrmgr01ApplyConfigChangeCB);
00778 #endif
00779 
00780     virtual XrlCmdError rtrmgr_0_1_lock_config(
00781     // Input values,
00782     const string&   token,
00783     const uint32_t& timeout,
00784     // Output values,
00785     bool&   success,
00786     uint32_t&   holder) = 0;
00787 #ifdef XORP_ENABLE_ASYNC_SERVER
00788     typedef
00789     XorpCallback3<void, const XrlCmdError &,
00790     const bool*,
00791     const uint32_t*>::RefPtr
00792     Rtrmgr01LockConfigRF;
00793 
00794     class Rtrmgr01LockConfigCB {
00795         Rtrmgr01LockConfigRF cb;
00796 
00797     public:
00798         operator const Rtrmgr01LockConfigRF& () const { return cb; }
00799         const Rtrmgr01LockConfigRF& operator ->() const { return cb; }
00800         Rtrmgr01LockConfigCB(const Rtrmgr01LockConfigRF& cb)
00801           : cb(cb) { }
00802 
00803         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00804 
00805         void respond(const bool& arg_success,
00806                      const uint32_t& arg_holder) const {
00807             cb->dispatch(XrlCmdError::OKAY(),
00808                          &arg_success,
00809                          &arg_holder);
00810         }
00811     };
00812 
00813     struct Rtrmgr01LockConfigRsp :
00814       public Rtrmgr01LockConfigCB {
00815         struct args_str {
00816             bool success;
00817             uint32_t holder;
00818         };
00819 
00820     private:
00821         args_str args;
00822 
00823     public:
00824         Rtrmgr01LockConfigRsp(const Rtrmgr01LockConfigRF& cb)
00825           : Rtrmgr01LockConfigCB(cb) { }
00826 
00827         void respond() const {
00828             Rtrmgr01LockConfigCB::
00829             respond(args.success,
00830                         args.holder);
00831         }
00832 
00833         args_str* operator ->() {
00834             return &args;
00835         }
00836     };
00837 
00838     virtual void async_rtrmgr_0_1_lock_config
00839        (
00840     const string&   token,
00841     const uint32_t& timeout,
00842     Rtrmgr01LockConfigCB);
00843 #endif
00844 
00845     virtual XrlCmdError rtrmgr_0_1_unlock_config(
00846     // Input values,
00847     const string&   token) = 0;
00848 #ifdef XORP_ENABLE_ASYNC_SERVER
00849     typedef
00850     XorpCallback1<void, const XrlCmdError &>::RefPtr
00851     Rtrmgr01UnlockConfigRF;
00852 
00853     class Rtrmgr01UnlockConfigCB {
00854         Rtrmgr01UnlockConfigRF cb;
00855 
00856     public:
00857         operator const Rtrmgr01UnlockConfigRF& () const { return cb; }
00858         const Rtrmgr01UnlockConfigRF& operator ->() const { return cb; }
00859         Rtrmgr01UnlockConfigCB(const Rtrmgr01UnlockConfigRF& cb)
00860           : cb(cb) { }
00861 
00862         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00863 
00864         void respond() const {
00865             cb->dispatch(XrlCmdError::OKAY());
00866         }
00867     };
00868 
00869     struct Rtrmgr01UnlockConfigRsp :
00870       public Rtrmgr01UnlockConfigCB {
00871         Rtrmgr01UnlockConfigRsp(const Rtrmgr01UnlockConfigRF& cb)
00872           : Rtrmgr01UnlockConfigCB(cb) { }
00873 
00874     };
00875 
00876     virtual void async_rtrmgr_0_1_unlock_config
00877        (
00878     const string&   token,
00879     Rtrmgr01UnlockConfigCB);
00880 #endif
00881 
00882     virtual XrlCmdError rtrmgr_0_1_lock_node(
00883     // Input values,
00884     const string&   token,
00885     const string&   node,
00886     const uint32_t& timeout,
00887     // Output values,
00888     bool&   success,
00889     uint32_t&   holder) = 0;
00890 #ifdef XORP_ENABLE_ASYNC_SERVER
00891     typedef
00892     XorpCallback3<void, const XrlCmdError &,
00893     const bool*,
00894     const uint32_t*>::RefPtr
00895     Rtrmgr01LockNodeRF;
00896 
00897     class Rtrmgr01LockNodeCB {
00898         Rtrmgr01LockNodeRF cb;
00899 
00900     public:
00901         operator const Rtrmgr01LockNodeRF& () const { return cb; }
00902         const Rtrmgr01LockNodeRF& operator ->() const { return cb; }
00903         Rtrmgr01LockNodeCB(const Rtrmgr01LockNodeRF& cb)
00904           : cb(cb) { }
00905 
00906         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00907 
00908         void respond(const bool& arg_success,
00909                      const uint32_t& arg_holder) const {
00910             cb->dispatch(XrlCmdError::OKAY(),
00911                          &arg_success,
00912                          &arg_holder);
00913         }
00914     };
00915 
00916     struct Rtrmgr01LockNodeRsp :
00917       public Rtrmgr01LockNodeCB {
00918         struct args_str {
00919             bool success;
00920             uint32_t holder;
00921         };
00922 
00923     private:
00924         args_str args;
00925 
00926     public:
00927         Rtrmgr01LockNodeRsp(const Rtrmgr01LockNodeRF& cb)
00928           : Rtrmgr01LockNodeCB(cb) { }
00929 
00930         void respond() const {
00931             Rtrmgr01LockNodeCB::
00932             respond(args.success,
00933                         args.holder);
00934         }
00935 
00936         args_str* operator ->() {
00937             return &args;
00938         }
00939     };
00940 
00941     virtual void async_rtrmgr_0_1_lock_node
00942        (
00943     const string&   token,
00944     const string&   node,
00945     const uint32_t& timeout,
00946     Rtrmgr01LockNodeCB);
00947 #endif
00948 
00949     virtual XrlCmdError rtrmgr_0_1_unlock_node(
00950     // Input values,
00951     const string&   token,
00952     const string&   node) = 0;
00953 #ifdef XORP_ENABLE_ASYNC_SERVER
00954     typedef
00955     XorpCallback1<void, const XrlCmdError &>::RefPtr
00956     Rtrmgr01UnlockNodeRF;
00957 
00958     class Rtrmgr01UnlockNodeCB {
00959         Rtrmgr01UnlockNodeRF cb;
00960 
00961     public:
00962         operator const Rtrmgr01UnlockNodeRF& () const { return cb; }
00963         const Rtrmgr01UnlockNodeRF& operator ->() const { return cb; }
00964         Rtrmgr01UnlockNodeCB(const Rtrmgr01UnlockNodeRF& cb)
00965           : cb(cb) { }
00966 
00967         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00968 
00969         void respond() const {
00970             cb->dispatch(XrlCmdError::OKAY());
00971         }
00972     };
00973 
00974     struct Rtrmgr01UnlockNodeRsp :
00975       public Rtrmgr01UnlockNodeCB {
00976         Rtrmgr01UnlockNodeRsp(const Rtrmgr01UnlockNodeRF& cb)
00977           : Rtrmgr01UnlockNodeCB(cb) { }
00978 
00979     };
00980 
00981     virtual void async_rtrmgr_0_1_unlock_node
00982        (
00983     const string&   token,
00984     const string&   node,
00985     Rtrmgr01UnlockNodeCB);
00986 #endif
00987 
00988     virtual XrlCmdError rtrmgr_0_1_save_config(
00989     // Input values,
00990     const string&   token,
00991     const string&   target,
00992     const string&   filename) = 0;
00993 #ifdef XORP_ENABLE_ASYNC_SERVER
00994     typedef
00995     XorpCallback1<void, const XrlCmdError &>::RefPtr
00996     Rtrmgr01SaveConfigRF;
00997 
00998     class Rtrmgr01SaveConfigCB {
00999         Rtrmgr01SaveConfigRF cb;
01000 
01001     public:
01002         operator const Rtrmgr01SaveConfigRF& () const { return cb; }
01003         const Rtrmgr01SaveConfigRF& operator ->() const { return cb; }
01004         Rtrmgr01SaveConfigCB(const Rtrmgr01SaveConfigRF& cb)
01005           : cb(cb) { }
01006 
01007         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01008 
01009         void respond() const {
01010             cb->dispatch(XrlCmdError::OKAY());
01011         }
01012     };
01013 
01014     struct Rtrmgr01SaveConfigRsp :
01015       public Rtrmgr01SaveConfigCB {
01016         Rtrmgr01SaveConfigRsp(const Rtrmgr01SaveConfigRF& cb)
01017           : Rtrmgr01SaveConfigCB(cb) { }
01018 
01019     };
01020 
01021     virtual void async_rtrmgr_0_1_save_config
01022        (
01023     const string&   token,
01024     const string&   target,
01025     const string&   filename,
01026     Rtrmgr01SaveConfigCB);
01027 #endif
01028 
01029     virtual XrlCmdError rtrmgr_0_1_load_config(
01030     // Input values,
01031     const string&   token,
01032     const string&   target,
01033     const string&   filename) = 0;
01034 #ifdef XORP_ENABLE_ASYNC_SERVER
01035     typedef
01036     XorpCallback1<void, const XrlCmdError &>::RefPtr
01037     Rtrmgr01LoadConfigRF;
01038 
01039     class Rtrmgr01LoadConfigCB {
01040         Rtrmgr01LoadConfigRF cb;
01041 
01042     public:
01043         operator const Rtrmgr01LoadConfigRF& () const { return cb; }
01044         const Rtrmgr01LoadConfigRF& operator ->() const { return cb; }
01045         Rtrmgr01LoadConfigCB(const Rtrmgr01LoadConfigRF& cb)
01046           : cb(cb) { }
01047 
01048         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01049 
01050         void respond() const {
01051             cb->dispatch(XrlCmdError::OKAY());
01052         }
01053     };
01054 
01055     struct Rtrmgr01LoadConfigRsp :
01056       public Rtrmgr01LoadConfigCB {
01057         Rtrmgr01LoadConfigRsp(const Rtrmgr01LoadConfigRF& cb)
01058           : Rtrmgr01LoadConfigCB(cb) { }
01059 
01060     };
01061 
01062     virtual void async_rtrmgr_0_1_load_config
01063        (
01064     const string&   token,
01065     const string&   target,
01066     const string&   filename,
01067     Rtrmgr01LoadConfigCB);
01068 #endif
01069 
01078     virtual XrlCmdError rtrmgr_0_1_set_config_directory(
01079     // Input values,
01080     const string&   config_directory) = 0;
01081 #ifdef XORP_ENABLE_ASYNC_SERVER
01082     typedef
01083     XorpCallback1<void, const XrlCmdError &>::RefPtr
01084     Rtrmgr01SetConfigDirectoryRF;
01085 
01086     class Rtrmgr01SetConfigDirectoryCB {
01087         Rtrmgr01SetConfigDirectoryRF cb;
01088 
01089     public:
01090         operator const Rtrmgr01SetConfigDirectoryRF& () const { return cb; }
01091         const Rtrmgr01SetConfigDirectoryRF& operator ->() const { return cb; }
01092         Rtrmgr01SetConfigDirectoryCB(const Rtrmgr01SetConfigDirectoryRF& cb)
01093           : cb(cb) { }
01094 
01095         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01096 
01097         void respond() const {
01098             cb->dispatch(XrlCmdError::OKAY());
01099         }
01100     };
01101 
01102     struct Rtrmgr01SetConfigDirectoryRsp :
01103       public Rtrmgr01SetConfigDirectoryCB {
01104         Rtrmgr01SetConfigDirectoryRsp(const Rtrmgr01SetConfigDirectoryRF& cb)
01105           : Rtrmgr01SetConfigDirectoryCB(cb) { }
01106 
01107     };
01108 
01109     virtual void async_rtrmgr_0_1_set_config_directory
01110        (
01111     const string&   config_directory,
01112     Rtrmgr01SetConfigDirectoryCB);
01113 #endif
01114 
01124     virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
01125     // Input values,
01126     const string&   target_class,
01127     const string&   target_instance) = 0;
01128 #ifdef XORP_ENABLE_ASYNC_SERVER
01129     typedef
01130     XorpCallback1<void, const XrlCmdError &>::RefPtr
01131     FinderEventObserver01XrlTargetBirthRF;
01132 
01133     class FinderEventObserver01XrlTargetBirthCB {
01134         FinderEventObserver01XrlTargetBirthRF cb;
01135 
01136     public:
01137         operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
01138         const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
01139         FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
01140           : cb(cb) { }
01141 
01142         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01143 
01144         void respond() const {
01145             cb->dispatch(XrlCmdError::OKAY());
01146         }
01147     };
01148 
01149     struct FinderEventObserver01XrlTargetBirthRsp :
01150       public FinderEventObserver01XrlTargetBirthCB {
01151         FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
01152           : FinderEventObserver01XrlTargetBirthCB(cb) { }
01153 
01154     };
01155 
01156     virtual void async_finder_event_observer_0_1_xrl_target_birth
01157        (
01158     const string&   target_class,
01159     const string&   target_instance,
01160     FinderEventObserver01XrlTargetBirthCB);
01161 #endif
01162 
01172     virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
01173     // Input values,
01174     const string&   target_class,
01175     const string&   target_instance) = 0;
01176 #ifdef XORP_ENABLE_ASYNC_SERVER
01177     typedef
01178     XorpCallback1<void, const XrlCmdError &>::RefPtr
01179     FinderEventObserver01XrlTargetDeathRF;
01180 
01181     class FinderEventObserver01XrlTargetDeathCB {
01182         FinderEventObserver01XrlTargetDeathRF cb;
01183 
01184     public:
01185         operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
01186         const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
01187         FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
01188           : cb(cb) { }
01189 
01190         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01191 
01192         void respond() const {
01193             cb->dispatch(XrlCmdError::OKAY());
01194         }
01195     };
01196 
01197     struct FinderEventObserver01XrlTargetDeathRsp :
01198       public FinderEventObserver01XrlTargetDeathCB {
01199         FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
01200           : FinderEventObserver01XrlTargetDeathCB(cb) { }
01201 
01202     };
01203 
01204     virtual void async_finder_event_observer_0_1_xrl_target_death
01205        (
01206     const string&   target_class,
01207     const string&   target_instance,
01208     FinderEventObserver01XrlTargetDeathCB);
01209 #endif
01210 
01211 private:
01212     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
01213 #ifdef XORP_ENABLE_ASYNC_SERVER
01214     void callback_common_0_1_get_target_name
01215        (const XrlCmdError &e,
01216     const string* arg_name,
01217         XrlRespCallback);
01218 #endif
01219 
01220     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
01221 #ifdef XORP_ENABLE_ASYNC_SERVER
01222     void callback_common_0_1_get_version
01223        (const XrlCmdError &e,
01224     const string* arg_version,
01225         XrlRespCallback);
01226 #endif
01227 
01228     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
01229 #ifdef XORP_ENABLE_ASYNC_SERVER
01230     void callback_common_0_1_get_status
01231        (const XrlCmdError &e,
01232     const uint32_t* arg_status,
01233     const string* arg_reason,
01234         XrlRespCallback);
01235 #endif
01236 
01237     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
01238 #ifdef XORP_ENABLE_ASYNC_SERVER
01239     void callback_common_0_1_shutdown
01240        (const XrlCmdError &e,
01241         XrlRespCallback);
01242 #endif
01243 
01244     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
01245 #ifdef XORP_ENABLE_ASYNC_SERVER
01246     void callback_common_0_1_startup
01247        (const XrlCmdError &e,
01248         XrlRespCallback);
01249 #endif
01250 
01251     XrlCmdRT handle_rtrmgr_0_1_get_pid(const XrlArgs& in, XrlCmdOT out);
01252 #ifdef XORP_ENABLE_ASYNC_SERVER
01253     void callback_rtrmgr_0_1_get_pid
01254        (const XrlCmdError &e,
01255     const uint32_t* arg_pid,
01256         XrlRespCallback);
01257 #endif
01258 
01259     XrlCmdRT handle_rtrmgr_0_1_register_client(const XrlArgs& in, XrlCmdOT out);
01260 #ifdef XORP_ENABLE_ASYNC_SERVER
01261     void callback_rtrmgr_0_1_register_client
01262        (const XrlCmdError &e,
01263     const string* arg_filename,
01264     const uint32_t* arg_pid,
01265     const uint32_t* arg_clientid,
01266         XrlRespCallback);
01267 #endif
01268 
01269     XrlCmdRT handle_rtrmgr_0_1_unregister_client(const XrlArgs& in, XrlCmdOT out);
01270 #ifdef XORP_ENABLE_ASYNC_SERVER
01271     void callback_rtrmgr_0_1_unregister_client
01272        (const XrlCmdError &e,
01273         XrlRespCallback);
01274 #endif
01275 
01276     XrlCmdRT handle_rtrmgr_0_1_authenticate_client(const XrlArgs& in, XrlCmdOT out);
01277 #ifdef XORP_ENABLE_ASYNC_SERVER
01278     void callback_rtrmgr_0_1_authenticate_client
01279        (const XrlCmdError &e,
01280         XrlRespCallback);
01281 #endif
01282 
01283     XrlCmdRT handle_rtrmgr_0_1_enter_config_mode(const XrlArgs& in, XrlCmdOT out);
01284 #ifdef XORP_ENABLE_ASYNC_SERVER
01285     void callback_rtrmgr_0_1_enter_config_mode
01286        (const XrlCmdError &e,
01287         XrlRespCallback);
01288 #endif
01289 
01290     XrlCmdRT handle_rtrmgr_0_1_leave_config_mode(const XrlArgs& in, XrlCmdOT out);
01291 #ifdef XORP_ENABLE_ASYNC_SERVER
01292     void callback_rtrmgr_0_1_leave_config_mode
01293        (const XrlCmdError &e,
01294         XrlRespCallback);
01295 #endif
01296 
01297     XrlCmdRT handle_rtrmgr_0_1_get_config_users(const XrlArgs& in, XrlCmdOT out);
01298 #ifdef XORP_ENABLE_ASYNC_SERVER
01299     void callback_rtrmgr_0_1_get_config_users
01300        (const XrlCmdError &e,
01301     const XrlAtomList* arg_users,
01302         XrlRespCallback);
01303 #endif
01304 
01305     XrlCmdRT handle_rtrmgr_0_1_get_running_config(const XrlArgs& in, XrlCmdOT out);
01306 #ifdef XORP_ENABLE_ASYNC_SERVER
01307     void callback_rtrmgr_0_1_get_running_config
01308        (const XrlCmdError &e,
01309     const bool* arg_ready,
01310     const string* arg_config,
01311         XrlRespCallback);
01312 #endif
01313 
01314     XrlCmdRT handle_rtrmgr_0_1_apply_config_change(const XrlArgs& in, XrlCmdOT out);
01315 #ifdef XORP_ENABLE_ASYNC_SERVER
01316     void callback_rtrmgr_0_1_apply_config_change
01317        (const XrlCmdError &e,
01318         XrlRespCallback);
01319 #endif
01320 
01321     XrlCmdRT handle_rtrmgr_0_1_lock_config(const XrlArgs& in, XrlCmdOT out);
01322 #ifdef XORP_ENABLE_ASYNC_SERVER
01323     void callback_rtrmgr_0_1_lock_config
01324        (const XrlCmdError &e,
01325     const bool* arg_success,
01326     const uint32_t* arg_holder,
01327         XrlRespCallback);
01328 #endif
01329 
01330     XrlCmdRT handle_rtrmgr_0_1_unlock_config(const XrlArgs& in, XrlCmdOT out);
01331 #ifdef XORP_ENABLE_ASYNC_SERVER
01332     void callback_rtrmgr_0_1_unlock_config
01333        (const XrlCmdError &e,
01334         XrlRespCallback);
01335 #endif
01336 
01337     XrlCmdRT handle_rtrmgr_0_1_lock_node(const XrlArgs& in, XrlCmdOT out);
01338 #ifdef XORP_ENABLE_ASYNC_SERVER
01339     void callback_rtrmgr_0_1_lock_node
01340        (const XrlCmdError &e,
01341     const bool* arg_success,
01342     const uint32_t* arg_holder,
01343         XrlRespCallback);
01344 #endif
01345 
01346     XrlCmdRT handle_rtrmgr_0_1_unlock_node(const XrlArgs& in, XrlCmdOT out);
01347 #ifdef XORP_ENABLE_ASYNC_SERVER
01348     void callback_rtrmgr_0_1_unlock_node
01349        (const XrlCmdError &e,
01350         XrlRespCallback);
01351 #endif
01352 
01353     XrlCmdRT handle_rtrmgr_0_1_save_config(const XrlArgs& in, XrlCmdOT out);
01354 #ifdef XORP_ENABLE_ASYNC_SERVER
01355     void callback_rtrmgr_0_1_save_config
01356        (const XrlCmdError &e,
01357         XrlRespCallback);
01358 #endif
01359 
01360     XrlCmdRT handle_rtrmgr_0_1_load_config(const XrlArgs& in, XrlCmdOT out);
01361 #ifdef XORP_ENABLE_ASYNC_SERVER
01362     void callback_rtrmgr_0_1_load_config
01363        (const XrlCmdError &e,
01364         XrlRespCallback);
01365 #endif
01366 
01367     XrlCmdRT handle_rtrmgr_0_1_set_config_directory(const XrlArgs& in, XrlCmdOT out);
01368 #ifdef XORP_ENABLE_ASYNC_SERVER
01369     void callback_rtrmgr_0_1_set_config_directory
01370        (const XrlCmdError &e,
01371         XrlRespCallback);
01372 #endif
01373 
01374     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
01375 #ifdef XORP_ENABLE_ASYNC_SERVER
01376     void callback_finder_event_observer_0_1_xrl_target_birth
01377        (const XrlCmdError &e,
01378         XrlRespCallback);
01379 #endif
01380 
01381     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
01382 #ifdef XORP_ENABLE_ASYNC_SERVER
01383     void callback_finder_event_observer_0_1_xrl_target_death
01384        (const XrlCmdError &e,
01385         XrlRespCallback);
01386 #endif
01387 
01388     void add_handlers();
01389     void remove_handlers();
01390 
01391     struct handler_table {
01392         const char *name;
01393         XrlCmdRT (XrlRtrmgrTargetBase::*method)(const XrlArgs&, XrlCmdOT);
01394     };
01395 
01396     static const struct handler_table handlers[];
01397     static const size_t num_handlers;
01398 };
01399 
01400 #endif // __XRL_TARGETS_RTRMGR_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations