xorp

finder_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/finder_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_FINDER_BASE_HH__
00016 #define __XRL_TARGETS_FINDER_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlFinderTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlFinderTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlFinderTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlFinderTargetBase();
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 "finder/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 
00341     virtual XrlCmdError finder_0_2_register_finder_client(
00342     // Input values,
00343     const string&   instance_name,
00344     const string&   class_name,
00345     const bool& singleton,
00346     const string&   in_cookie,
00347     // Output values,
00348     string& out_cookie) = 0;
00349 #ifdef XORP_ENABLE_ASYNC_SERVER
00350     typedef
00351     XorpCallback2<void, const XrlCmdError &,
00352     const string*>::RefPtr
00353     Finder02RegisterFinderClientRF;
00354 
00355     class Finder02RegisterFinderClientCB {
00356         Finder02RegisterFinderClientRF cb;
00357 
00358     public:
00359         operator const Finder02RegisterFinderClientRF& () const { return cb; }
00360         const Finder02RegisterFinderClientRF& operator ->() const { return cb; }
00361         Finder02RegisterFinderClientCB(const Finder02RegisterFinderClientRF& cb)
00362           : cb(cb) { }
00363 
00364         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00365 
00366         void respond(const string& arg_out_cookie) const {
00367             cb->dispatch(XrlCmdError::OKAY(),
00368                          &arg_out_cookie);
00369         }
00370     };
00371 
00372     struct Finder02RegisterFinderClientRsp :
00373       public Finder02RegisterFinderClientCB {
00374         struct args_str {
00375             string out_cookie;
00376         };
00377 
00378     private:
00379         args_str args;
00380 
00381     public:
00382         Finder02RegisterFinderClientRsp(const Finder02RegisterFinderClientRF& cb)
00383           : Finder02RegisterFinderClientCB(cb) { }
00384 
00385         void respond() const {
00386             Finder02RegisterFinderClientCB::
00387             respond(args.out_cookie);
00388         }
00389 
00390         args_str* operator ->() {
00391             return &args;
00392         }
00393     };
00394 
00395     virtual void async_finder_0_2_register_finder_client
00396        (
00397     const string&   instance_name,
00398     const string&   class_name,
00399     const bool& singleton,
00400     const string&   in_cookie,
00401     Finder02RegisterFinderClientCB);
00402 #endif
00403 
00404     virtual XrlCmdError finder_0_2_unregister_finder_client(
00405     // Input values,
00406     const string&   instance_name) = 0;
00407 #ifdef XORP_ENABLE_ASYNC_SERVER
00408     typedef
00409     XorpCallback1<void, const XrlCmdError &>::RefPtr
00410     Finder02UnregisterFinderClientRF;
00411 
00412     class Finder02UnregisterFinderClientCB {
00413         Finder02UnregisterFinderClientRF cb;
00414 
00415     public:
00416         operator const Finder02UnregisterFinderClientRF& () const { return cb; }
00417         const Finder02UnregisterFinderClientRF& operator ->() const { return cb; }
00418         Finder02UnregisterFinderClientCB(const Finder02UnregisterFinderClientRF& cb)
00419           : cb(cb) { }
00420 
00421         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00422 
00423         void respond() const {
00424             cb->dispatch(XrlCmdError::OKAY());
00425         }
00426     };
00427 
00428     struct Finder02UnregisterFinderClientRsp :
00429       public Finder02UnregisterFinderClientCB {
00430         Finder02UnregisterFinderClientRsp(const Finder02UnregisterFinderClientRF& cb)
00431           : Finder02UnregisterFinderClientCB(cb) { }
00432 
00433     };
00434 
00435     virtual void async_finder_0_2_unregister_finder_client
00436        (
00437     const string&   instance_name,
00438     Finder02UnregisterFinderClientCB);
00439 #endif
00440 
00449     virtual XrlCmdError finder_0_2_set_finder_client_enabled(
00450     // Input values,
00451     const string&   instance_name,
00452     const bool& enabled) = 0;
00453 #ifdef XORP_ENABLE_ASYNC_SERVER
00454     typedef
00455     XorpCallback1<void, const XrlCmdError &>::RefPtr
00456     Finder02SetFinderClientEnabledRF;
00457 
00458     class Finder02SetFinderClientEnabledCB {
00459         Finder02SetFinderClientEnabledRF cb;
00460 
00461     public:
00462         operator const Finder02SetFinderClientEnabledRF& () const { return cb; }
00463         const Finder02SetFinderClientEnabledRF& operator ->() const { return cb; }
00464         Finder02SetFinderClientEnabledCB(const Finder02SetFinderClientEnabledRF& cb)
00465           : cb(cb) { }
00466 
00467         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00468 
00469         void respond() const {
00470             cb->dispatch(XrlCmdError::OKAY());
00471         }
00472     };
00473 
00474     struct Finder02SetFinderClientEnabledRsp :
00475       public Finder02SetFinderClientEnabledCB {
00476         Finder02SetFinderClientEnabledRsp(const Finder02SetFinderClientEnabledRF& cb)
00477           : Finder02SetFinderClientEnabledCB(cb) { }
00478 
00479     };
00480 
00481     virtual void async_finder_0_2_set_finder_client_enabled
00482        (
00483     const string&   instance_name,
00484     const bool& enabled,
00485     Finder02SetFinderClientEnabledCB);
00486 #endif
00487 
00493     virtual XrlCmdError finder_0_2_finder_client_enabled(
00494     // Input values,
00495     const string&   instance_name,
00496     // Output values,
00497     bool&   enabled) = 0;
00498 #ifdef XORP_ENABLE_ASYNC_SERVER
00499     typedef
00500     XorpCallback2<void, const XrlCmdError &,
00501     const bool*>::RefPtr
00502     Finder02FinderClientEnabledRF;
00503 
00504     class Finder02FinderClientEnabledCB {
00505         Finder02FinderClientEnabledRF cb;
00506 
00507     public:
00508         operator const Finder02FinderClientEnabledRF& () const { return cb; }
00509         const Finder02FinderClientEnabledRF& operator ->() const { return cb; }
00510         Finder02FinderClientEnabledCB(const Finder02FinderClientEnabledRF& cb)
00511           : cb(cb) { }
00512 
00513         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00514 
00515         void respond(const bool& arg_enabled) const {
00516             cb->dispatch(XrlCmdError::OKAY(),
00517                          &arg_enabled);
00518         }
00519     };
00520 
00521     struct Finder02FinderClientEnabledRsp :
00522       public Finder02FinderClientEnabledCB {
00523         struct args_str {
00524             bool enabled;
00525         };
00526 
00527     private:
00528         args_str args;
00529 
00530     public:
00531         Finder02FinderClientEnabledRsp(const Finder02FinderClientEnabledRF& cb)
00532           : Finder02FinderClientEnabledCB(cb) { }
00533 
00534         void respond() const {
00535             Finder02FinderClientEnabledCB::
00536             respond(args.enabled);
00537         }
00538 
00539         args_str* operator ->() {
00540             return &args;
00541         }
00542     };
00543 
00544     virtual void async_finder_0_2_finder_client_enabled
00545        (
00546     const string&   instance_name,
00547     Finder02FinderClientEnabledCB);
00548 #endif
00549 
00555     virtual XrlCmdError finder_0_2_add_xrl(
00556     // Input values,
00557     const string&   xrl,
00558     const string&   protocol_name,
00559     const string&   protocol_args,
00560     // Output values,
00561     string& resolved_xrl_method_name) = 0;
00562 #ifdef XORP_ENABLE_ASYNC_SERVER
00563     typedef
00564     XorpCallback2<void, const XrlCmdError &,
00565     const string*>::RefPtr
00566     Finder02AddXrlRF;
00567 
00568     class Finder02AddXrlCB {
00569         Finder02AddXrlRF cb;
00570 
00571     public:
00572         operator const Finder02AddXrlRF& () const { return cb; }
00573         const Finder02AddXrlRF& operator ->() const { return cb; }
00574         Finder02AddXrlCB(const Finder02AddXrlRF& cb)
00575           : cb(cb) { }
00576 
00577         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00578 
00579         void respond(const string& arg_resolved_xrl_method_name) const {
00580             cb->dispatch(XrlCmdError::OKAY(),
00581                          &arg_resolved_xrl_method_name);
00582         }
00583     };
00584 
00585     struct Finder02AddXrlRsp :
00586       public Finder02AddXrlCB {
00587         struct args_str {
00588             string resolved_xrl_method_name;
00589         };
00590 
00591     private:
00592         args_str args;
00593 
00594     public:
00595         Finder02AddXrlRsp(const Finder02AddXrlRF& cb)
00596           : Finder02AddXrlCB(cb) { }
00597 
00598         void respond() const {
00599             Finder02AddXrlCB::
00600             respond(args.resolved_xrl_method_name);
00601         }
00602 
00603         args_str* operator ->() {
00604             return &args;
00605         }
00606     };
00607 
00608     virtual void async_finder_0_2_add_xrl
00609        (
00610     const string&   xrl,
00611     const string&   protocol_name,
00612     const string&   protocol_args,
00613     Finder02AddXrlCB);
00614 #endif
00615 
00621     virtual XrlCmdError finder_0_2_remove_xrl(
00622     // Input values,
00623     const string&   xrl) = 0;
00624 #ifdef XORP_ENABLE_ASYNC_SERVER
00625     typedef
00626     XorpCallback1<void, const XrlCmdError &>::RefPtr
00627     Finder02RemoveXrlRF;
00628 
00629     class Finder02RemoveXrlCB {
00630         Finder02RemoveXrlRF cb;
00631 
00632     public:
00633         operator const Finder02RemoveXrlRF& () const { return cb; }
00634         const Finder02RemoveXrlRF& operator ->() const { return cb; }
00635         Finder02RemoveXrlCB(const Finder02RemoveXrlRF& cb)
00636           : cb(cb) { }
00637 
00638         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00639 
00640         void respond() const {
00641             cb->dispatch(XrlCmdError::OKAY());
00642         }
00643     };
00644 
00645     struct Finder02RemoveXrlRsp :
00646       public Finder02RemoveXrlCB {
00647         Finder02RemoveXrlRsp(const Finder02RemoveXrlRF& cb)
00648           : Finder02RemoveXrlCB(cb) { }
00649 
00650     };
00651 
00652     virtual void async_finder_0_2_remove_xrl
00653        (
00654     const string&   xrl,
00655     Finder02RemoveXrlCB);
00656 #endif
00657 
00663     virtual XrlCmdError finder_0_2_resolve_xrl(
00664     // Input values,
00665     const string&   xrl,
00666     // Output values,
00667     XrlAtomList&    resolutions) = 0;
00668 #ifdef XORP_ENABLE_ASYNC_SERVER
00669     typedef
00670     XorpCallback2<void, const XrlCmdError &,
00671     const XrlAtomList*>::RefPtr
00672     Finder02ResolveXrlRF;
00673 
00674     class Finder02ResolveXrlCB {
00675         Finder02ResolveXrlRF cb;
00676 
00677     public:
00678         operator const Finder02ResolveXrlRF& () const { return cb; }
00679         const Finder02ResolveXrlRF& operator ->() const { return cb; }
00680         Finder02ResolveXrlCB(const Finder02ResolveXrlRF& cb)
00681           : cb(cb) { }
00682 
00683         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00684 
00685         void respond(const XrlAtomList& arg_resolutions) const {
00686             cb->dispatch(XrlCmdError::OKAY(),
00687                          &arg_resolutions);
00688         }
00689     };
00690 
00691     struct Finder02ResolveXrlRsp :
00692       public Finder02ResolveXrlCB {
00693         struct args_str {
00694             XrlAtomList resolutions;
00695         };
00696 
00697     private:
00698         args_str args;
00699 
00700     public:
00701         Finder02ResolveXrlRsp(const Finder02ResolveXrlRF& cb)
00702           : Finder02ResolveXrlCB(cb) { }
00703 
00704         void respond() const {
00705             Finder02ResolveXrlCB::
00706             respond(args.resolutions);
00707         }
00708 
00709         args_str* operator ->() {
00710             return &args;
00711         }
00712     };
00713 
00714     virtual void async_finder_0_2_resolve_xrl
00715        (
00716     const string&   xrl,
00717     Finder02ResolveXrlCB);
00718 #endif
00719 
00725     virtual XrlCmdError finder_0_2_get_xrl_targets(
00726     // Output values,
00727     XrlAtomList&    target_names) = 0;
00728 #ifdef XORP_ENABLE_ASYNC_SERVER
00729     typedef
00730     XorpCallback2<void, const XrlCmdError &,
00731     const XrlAtomList*>::RefPtr
00732     Finder02GetXrlTargetsRF;
00733 
00734     class Finder02GetXrlTargetsCB {
00735         Finder02GetXrlTargetsRF cb;
00736 
00737     public:
00738         operator const Finder02GetXrlTargetsRF& () const { return cb; }
00739         const Finder02GetXrlTargetsRF& operator ->() const { return cb; }
00740         Finder02GetXrlTargetsCB(const Finder02GetXrlTargetsRF& cb)
00741           : cb(cb) { }
00742 
00743         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00744 
00745         void respond(const XrlAtomList& arg_target_names) const {
00746             cb->dispatch(XrlCmdError::OKAY(),
00747                          &arg_target_names);
00748         }
00749     };
00750 
00751     struct Finder02GetXrlTargetsRsp :
00752       public Finder02GetXrlTargetsCB {
00753         struct args_str {
00754             XrlAtomList target_names;
00755         };
00756 
00757     private:
00758         args_str args;
00759 
00760     public:
00761         Finder02GetXrlTargetsRsp(const Finder02GetXrlTargetsRF& cb)
00762           : Finder02GetXrlTargetsCB(cb) { }
00763 
00764         void respond() const {
00765             Finder02GetXrlTargetsCB::
00766             respond(args.target_names);
00767         }
00768 
00769         args_str* operator ->() {
00770             return &args;
00771         }
00772     };
00773 
00774     virtual void async_finder_0_2_get_xrl_targets
00775        (
00776     Finder02GetXrlTargetsCB);
00777 #endif
00778 
00784     virtual XrlCmdError finder_0_2_get_xrls_registered_by(
00785     // Input values,
00786     const string&   target_name,
00787     // Output values,
00788     XrlAtomList&    xrls) = 0;
00789 #ifdef XORP_ENABLE_ASYNC_SERVER
00790     typedef
00791     XorpCallback2<void, const XrlCmdError &,
00792     const XrlAtomList*>::RefPtr
00793     Finder02GetXrlsRegisteredByRF;
00794 
00795     class Finder02GetXrlsRegisteredByCB {
00796         Finder02GetXrlsRegisteredByRF cb;
00797 
00798     public:
00799         operator const Finder02GetXrlsRegisteredByRF& () const { return cb; }
00800         const Finder02GetXrlsRegisteredByRF& operator ->() const { return cb; }
00801         Finder02GetXrlsRegisteredByCB(const Finder02GetXrlsRegisteredByRF& cb)
00802           : cb(cb) { }
00803 
00804         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00805 
00806         void respond(const XrlAtomList& arg_xrls) const {
00807             cb->dispatch(XrlCmdError::OKAY(),
00808                          &arg_xrls);
00809         }
00810     };
00811 
00812     struct Finder02GetXrlsRegisteredByRsp :
00813       public Finder02GetXrlsRegisteredByCB {
00814         struct args_str {
00815             XrlAtomList xrls;
00816         };
00817 
00818     private:
00819         args_str args;
00820 
00821     public:
00822         Finder02GetXrlsRegisteredByRsp(const Finder02GetXrlsRegisteredByRF& cb)
00823           : Finder02GetXrlsRegisteredByCB(cb) { }
00824 
00825         void respond() const {
00826             Finder02GetXrlsRegisteredByCB::
00827             respond(args.xrls);
00828         }
00829 
00830         args_str* operator ->() {
00831             return &args;
00832         }
00833     };
00834 
00835     virtual void async_finder_0_2_get_xrls_registered_by
00836        (
00837     const string&   target_name,
00838     Finder02GetXrlsRegisteredByCB);
00839 #endif
00840 
00846     virtual XrlCmdError finder_0_2_get_ipv4_permitted_hosts(
00847     // Output values,
00848     XrlAtomList&    ipv4s) = 0;
00849 #ifdef XORP_ENABLE_ASYNC_SERVER
00850     typedef
00851     XorpCallback2<void, const XrlCmdError &,
00852     const XrlAtomList*>::RefPtr
00853     Finder02GetIpv4PermittedHostsRF;
00854 
00855     class Finder02GetIpv4PermittedHostsCB {
00856         Finder02GetIpv4PermittedHostsRF cb;
00857 
00858     public:
00859         operator const Finder02GetIpv4PermittedHostsRF& () const { return cb; }
00860         const Finder02GetIpv4PermittedHostsRF& operator ->() const { return cb; }
00861         Finder02GetIpv4PermittedHostsCB(const Finder02GetIpv4PermittedHostsRF& cb)
00862           : cb(cb) { }
00863 
00864         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00865 
00866         void respond(const XrlAtomList& arg_ipv4s) const {
00867             cb->dispatch(XrlCmdError::OKAY(),
00868                          &arg_ipv4s);
00869         }
00870     };
00871 
00872     struct Finder02GetIpv4PermittedHostsRsp :
00873       public Finder02GetIpv4PermittedHostsCB {
00874         struct args_str {
00875             XrlAtomList ipv4s;
00876         };
00877 
00878     private:
00879         args_str args;
00880 
00881     public:
00882         Finder02GetIpv4PermittedHostsRsp(const Finder02GetIpv4PermittedHostsRF& cb)
00883           : Finder02GetIpv4PermittedHostsCB(cb) { }
00884 
00885         void respond() const {
00886             Finder02GetIpv4PermittedHostsCB::
00887             respond(args.ipv4s);
00888         }
00889 
00890         args_str* operator ->() {
00891             return &args;
00892         }
00893     };
00894 
00895     virtual void async_finder_0_2_get_ipv4_permitted_hosts
00896        (
00897     Finder02GetIpv4PermittedHostsCB);
00898 #endif
00899 
00905     virtual XrlCmdError finder_0_2_get_ipv4_permitted_nets(
00906     // Output values,
00907     XrlAtomList&    ipv4nets) = 0;
00908 #ifdef XORP_ENABLE_ASYNC_SERVER
00909     typedef
00910     XorpCallback2<void, const XrlCmdError &,
00911     const XrlAtomList*>::RefPtr
00912     Finder02GetIpv4PermittedNetsRF;
00913 
00914     class Finder02GetIpv4PermittedNetsCB {
00915         Finder02GetIpv4PermittedNetsRF cb;
00916 
00917     public:
00918         operator const Finder02GetIpv4PermittedNetsRF& () const { return cb; }
00919         const Finder02GetIpv4PermittedNetsRF& operator ->() const { return cb; }
00920         Finder02GetIpv4PermittedNetsCB(const Finder02GetIpv4PermittedNetsRF& cb)
00921           : cb(cb) { }
00922 
00923         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00924 
00925         void respond(const XrlAtomList& arg_ipv4nets) const {
00926             cb->dispatch(XrlCmdError::OKAY(),
00927                          &arg_ipv4nets);
00928         }
00929     };
00930 
00931     struct Finder02GetIpv4PermittedNetsRsp :
00932       public Finder02GetIpv4PermittedNetsCB {
00933         struct args_str {
00934             XrlAtomList ipv4nets;
00935         };
00936 
00937     private:
00938         args_str args;
00939 
00940     public:
00941         Finder02GetIpv4PermittedNetsRsp(const Finder02GetIpv4PermittedNetsRF& cb)
00942           : Finder02GetIpv4PermittedNetsCB(cb) { }
00943 
00944         void respond() const {
00945             Finder02GetIpv4PermittedNetsCB::
00946             respond(args.ipv4nets);
00947         }
00948 
00949         args_str* operator ->() {
00950             return &args;
00951         }
00952     };
00953 
00954     virtual void async_finder_0_2_get_ipv4_permitted_nets
00955        (
00956     Finder02GetIpv4PermittedNetsCB);
00957 #endif
00958 
00964     virtual XrlCmdError finder_0_2_get_ipv6_permitted_hosts(
00965     // Output values,
00966     XrlAtomList&    ipv6s) = 0;
00967 #ifdef XORP_ENABLE_ASYNC_SERVER
00968     typedef
00969     XorpCallback2<void, const XrlCmdError &,
00970     const XrlAtomList*>::RefPtr
00971     Finder02GetIpv6PermittedHostsRF;
00972 
00973     class Finder02GetIpv6PermittedHostsCB {
00974         Finder02GetIpv6PermittedHostsRF cb;
00975 
00976     public:
00977         operator const Finder02GetIpv6PermittedHostsRF& () const { return cb; }
00978         const Finder02GetIpv6PermittedHostsRF& operator ->() const { return cb; }
00979         Finder02GetIpv6PermittedHostsCB(const Finder02GetIpv6PermittedHostsRF& cb)
00980           : cb(cb) { }
00981 
00982         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00983 
00984         void respond(const XrlAtomList& arg_ipv6s) const {
00985             cb->dispatch(XrlCmdError::OKAY(),
00986                          &arg_ipv6s);
00987         }
00988     };
00989 
00990     struct Finder02GetIpv6PermittedHostsRsp :
00991       public Finder02GetIpv6PermittedHostsCB {
00992         struct args_str {
00993             XrlAtomList ipv6s;
00994         };
00995 
00996     private:
00997         args_str args;
00998 
00999     public:
01000         Finder02GetIpv6PermittedHostsRsp(const Finder02GetIpv6PermittedHostsRF& cb)
01001           : Finder02GetIpv6PermittedHostsCB(cb) { }
01002 
01003         void respond() const {
01004             Finder02GetIpv6PermittedHostsCB::
01005             respond(args.ipv6s);
01006         }
01007 
01008         args_str* operator ->() {
01009             return &args;
01010         }
01011     };
01012 
01013     virtual void async_finder_0_2_get_ipv6_permitted_hosts
01014        (
01015     Finder02GetIpv6PermittedHostsCB);
01016 #endif
01017 
01023     virtual XrlCmdError finder_0_2_get_ipv6_permitted_nets(
01024     // Output values,
01025     XrlAtomList&    ipv6nets) = 0;
01026 #ifdef XORP_ENABLE_ASYNC_SERVER
01027     typedef
01028     XorpCallback2<void, const XrlCmdError &,
01029     const XrlAtomList*>::RefPtr
01030     Finder02GetIpv6PermittedNetsRF;
01031 
01032     class Finder02GetIpv6PermittedNetsCB {
01033         Finder02GetIpv6PermittedNetsRF cb;
01034 
01035     public:
01036         operator const Finder02GetIpv6PermittedNetsRF& () const { return cb; }
01037         const Finder02GetIpv6PermittedNetsRF& operator ->() const { return cb; }
01038         Finder02GetIpv6PermittedNetsCB(const Finder02GetIpv6PermittedNetsRF& cb)
01039           : cb(cb) { }
01040 
01041         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01042 
01043         void respond(const XrlAtomList& arg_ipv6nets) const {
01044             cb->dispatch(XrlCmdError::OKAY(),
01045                          &arg_ipv6nets);
01046         }
01047     };
01048 
01049     struct Finder02GetIpv6PermittedNetsRsp :
01050       public Finder02GetIpv6PermittedNetsCB {
01051         struct args_str {
01052             XrlAtomList ipv6nets;
01053         };
01054 
01055     private:
01056         args_str args;
01057 
01058     public:
01059         Finder02GetIpv6PermittedNetsRsp(const Finder02GetIpv6PermittedNetsRF& cb)
01060           : Finder02GetIpv6PermittedNetsCB(cb) { }
01061 
01062         void respond() const {
01063             Finder02GetIpv6PermittedNetsCB::
01064             respond(args.ipv6nets);
01065         }
01066 
01067         args_str* operator ->() {
01068             return &args;
01069         }
01070     };
01071 
01072     virtual void async_finder_0_2_get_ipv6_permitted_nets
01073        (
01074     Finder02GetIpv6PermittedNetsCB);
01075 #endif
01076 
01092     virtual XrlCmdError finder_event_notifier_0_1_register_class_event_interest(
01093     // Input values,
01094     const string&   requester_instance,
01095     const string&   class_name) = 0;
01096 #ifdef XORP_ENABLE_ASYNC_SERVER
01097     typedef
01098     XorpCallback1<void, const XrlCmdError &>::RefPtr
01099     FinderEventNotifier01RegisterClassEventInterestRF;
01100 
01101     class FinderEventNotifier01RegisterClassEventInterestCB {
01102         FinderEventNotifier01RegisterClassEventInterestRF cb;
01103 
01104     public:
01105         operator const FinderEventNotifier01RegisterClassEventInterestRF& () const { return cb; }
01106         const FinderEventNotifier01RegisterClassEventInterestRF& operator ->() const { return cb; }
01107         FinderEventNotifier01RegisterClassEventInterestCB(const FinderEventNotifier01RegisterClassEventInterestRF& cb)
01108           : cb(cb) { }
01109 
01110         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01111 
01112         void respond() const {
01113             cb->dispatch(XrlCmdError::OKAY());
01114         }
01115     };
01116 
01117     struct FinderEventNotifier01RegisterClassEventInterestRsp :
01118       public FinderEventNotifier01RegisterClassEventInterestCB {
01119         FinderEventNotifier01RegisterClassEventInterestRsp(const FinderEventNotifier01RegisterClassEventInterestRF& cb)
01120           : FinderEventNotifier01RegisterClassEventInterestCB(cb) { }
01121 
01122     };
01123 
01124     virtual void async_finder_event_notifier_0_1_register_class_event_interest
01125        (
01126     const string&   requester_instance,
01127     const string&   class_name,
01128     FinderEventNotifier01RegisterClassEventInterestCB);
01129 #endif
01130 
01141     virtual XrlCmdError finder_event_notifier_0_1_deregister_class_event_interest(
01142     // Input values,
01143     const string&   requester_instance,
01144     const string&   class_name) = 0;
01145 #ifdef XORP_ENABLE_ASYNC_SERVER
01146     typedef
01147     XorpCallback1<void, const XrlCmdError &>::RefPtr
01148     FinderEventNotifier01DeregisterClassEventInterestRF;
01149 
01150     class FinderEventNotifier01DeregisterClassEventInterestCB {
01151         FinderEventNotifier01DeregisterClassEventInterestRF cb;
01152 
01153     public:
01154         operator const FinderEventNotifier01DeregisterClassEventInterestRF& () const { return cb; }
01155         const FinderEventNotifier01DeregisterClassEventInterestRF& operator ->() const { return cb; }
01156         FinderEventNotifier01DeregisterClassEventInterestCB(const FinderEventNotifier01DeregisterClassEventInterestRF& cb)
01157           : cb(cb) { }
01158 
01159         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01160 
01161         void respond() const {
01162             cb->dispatch(XrlCmdError::OKAY());
01163         }
01164     };
01165 
01166     struct FinderEventNotifier01DeregisterClassEventInterestRsp :
01167       public FinderEventNotifier01DeregisterClassEventInterestCB {
01168         FinderEventNotifier01DeregisterClassEventInterestRsp(const FinderEventNotifier01DeregisterClassEventInterestRF& cb)
01169           : FinderEventNotifier01DeregisterClassEventInterestCB(cb) { }
01170 
01171     };
01172 
01173     virtual void async_finder_event_notifier_0_1_deregister_class_event_interest
01174        (
01175     const string&   requester_instance,
01176     const string&   class_name,
01177     FinderEventNotifier01DeregisterClassEventInterestCB);
01178 #endif
01179 
01195     virtual XrlCmdError finder_event_notifier_0_1_register_instance_event_interest(
01196     // Input values,
01197     const string&   requester_instance,
01198     const string&   instance_name) = 0;
01199 #ifdef XORP_ENABLE_ASYNC_SERVER
01200     typedef
01201     XorpCallback1<void, const XrlCmdError &>::RefPtr
01202     FinderEventNotifier01RegisterInstanceEventInterestRF;
01203 
01204     class FinderEventNotifier01RegisterInstanceEventInterestCB {
01205         FinderEventNotifier01RegisterInstanceEventInterestRF cb;
01206 
01207     public:
01208         operator const FinderEventNotifier01RegisterInstanceEventInterestRF& () const { return cb; }
01209         const FinderEventNotifier01RegisterInstanceEventInterestRF& operator ->() const { return cb; }
01210         FinderEventNotifier01RegisterInstanceEventInterestCB(const FinderEventNotifier01RegisterInstanceEventInterestRF& cb)
01211           : cb(cb) { }
01212 
01213         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01214 
01215         void respond() const {
01216             cb->dispatch(XrlCmdError::OKAY());
01217         }
01218     };
01219 
01220     struct FinderEventNotifier01RegisterInstanceEventInterestRsp :
01221       public FinderEventNotifier01RegisterInstanceEventInterestCB {
01222         FinderEventNotifier01RegisterInstanceEventInterestRsp(const FinderEventNotifier01RegisterInstanceEventInterestRF& cb)
01223           : FinderEventNotifier01RegisterInstanceEventInterestCB(cb) { }
01224 
01225     };
01226 
01227     virtual void async_finder_event_notifier_0_1_register_instance_event_interest
01228        (
01229     const string&   requester_instance,
01230     const string&   instance_name,
01231     FinderEventNotifier01RegisterInstanceEventInterestCB);
01232 #endif
01233 
01245     virtual XrlCmdError finder_event_notifier_0_1_deregister_instance_event_interest(
01246     // Input values,
01247     const string&   requester_instance,
01248     const string&   instance_name) = 0;
01249 #ifdef XORP_ENABLE_ASYNC_SERVER
01250     typedef
01251     XorpCallback1<void, const XrlCmdError &>::RefPtr
01252     FinderEventNotifier01DeregisterInstanceEventInterestRF;
01253 
01254     class FinderEventNotifier01DeregisterInstanceEventInterestCB {
01255         FinderEventNotifier01DeregisterInstanceEventInterestRF cb;
01256 
01257     public:
01258         operator const FinderEventNotifier01DeregisterInstanceEventInterestRF& () const { return cb; }
01259         const FinderEventNotifier01DeregisterInstanceEventInterestRF& operator ->() const { return cb; }
01260         FinderEventNotifier01DeregisterInstanceEventInterestCB(const FinderEventNotifier01DeregisterInstanceEventInterestRF& cb)
01261           : cb(cb) { }
01262 
01263         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01264 
01265         void respond() const {
01266             cb->dispatch(XrlCmdError::OKAY());
01267         }
01268     };
01269 
01270     struct FinderEventNotifier01DeregisterInstanceEventInterestRsp :
01271       public FinderEventNotifier01DeregisterInstanceEventInterestCB {
01272         FinderEventNotifier01DeregisterInstanceEventInterestRsp(const FinderEventNotifier01DeregisterInstanceEventInterestRF& cb)
01273           : FinderEventNotifier01DeregisterInstanceEventInterestCB(cb) { }
01274 
01275     };
01276 
01277     virtual void async_finder_event_notifier_0_1_deregister_instance_event_interest
01278        (
01279     const string&   requester_instance,
01280     const string&   instance_name,
01281     FinderEventNotifier01DeregisterInstanceEventInterestCB);
01282 #endif
01283 
01284 private:
01285     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
01286 #ifdef XORP_ENABLE_ASYNC_SERVER
01287     void callback_common_0_1_get_target_name
01288        (const XrlCmdError &e,
01289     const string* arg_name,
01290         XrlRespCallback);
01291 #endif
01292 
01293     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
01294 #ifdef XORP_ENABLE_ASYNC_SERVER
01295     void callback_common_0_1_get_version
01296        (const XrlCmdError &e,
01297     const string* arg_version,
01298         XrlRespCallback);
01299 #endif
01300 
01301     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
01302 #ifdef XORP_ENABLE_ASYNC_SERVER
01303     void callback_common_0_1_get_status
01304        (const XrlCmdError &e,
01305     const uint32_t* arg_status,
01306     const string* arg_reason,
01307         XrlRespCallback);
01308 #endif
01309 
01310     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
01311 #ifdef XORP_ENABLE_ASYNC_SERVER
01312     void callback_common_0_1_shutdown
01313        (const XrlCmdError &e,
01314         XrlRespCallback);
01315 #endif
01316 
01317     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
01318 #ifdef XORP_ENABLE_ASYNC_SERVER
01319     void callback_common_0_1_startup
01320        (const XrlCmdError &e,
01321         XrlRespCallback);
01322 #endif
01323 
01324     XrlCmdRT handle_finder_0_2_register_finder_client(const XrlArgs& in, XrlCmdOT out);
01325 #ifdef XORP_ENABLE_ASYNC_SERVER
01326     void callback_finder_0_2_register_finder_client
01327        (const XrlCmdError &e,
01328     const string* arg_out_cookie,
01329         XrlRespCallback);
01330 #endif
01331 
01332     XrlCmdRT handle_finder_0_2_unregister_finder_client(const XrlArgs& in, XrlCmdOT out);
01333 #ifdef XORP_ENABLE_ASYNC_SERVER
01334     void callback_finder_0_2_unregister_finder_client
01335        (const XrlCmdError &e,
01336         XrlRespCallback);
01337 #endif
01338 
01339     XrlCmdRT handle_finder_0_2_set_finder_client_enabled(const XrlArgs& in, XrlCmdOT out);
01340 #ifdef XORP_ENABLE_ASYNC_SERVER
01341     void callback_finder_0_2_set_finder_client_enabled
01342        (const XrlCmdError &e,
01343         XrlRespCallback);
01344 #endif
01345 
01346     XrlCmdRT handle_finder_0_2_finder_client_enabled(const XrlArgs& in, XrlCmdOT out);
01347 #ifdef XORP_ENABLE_ASYNC_SERVER
01348     void callback_finder_0_2_finder_client_enabled
01349        (const XrlCmdError &e,
01350     const bool* arg_enabled,
01351         XrlRespCallback);
01352 #endif
01353 
01354     XrlCmdRT handle_finder_0_2_add_xrl(const XrlArgs& in, XrlCmdOT out);
01355 #ifdef XORP_ENABLE_ASYNC_SERVER
01356     void callback_finder_0_2_add_xrl
01357        (const XrlCmdError &e,
01358     const string* arg_resolved_xrl_method_name,
01359         XrlRespCallback);
01360 #endif
01361 
01362     XrlCmdRT handle_finder_0_2_remove_xrl(const XrlArgs& in, XrlCmdOT out);
01363 #ifdef XORP_ENABLE_ASYNC_SERVER
01364     void callback_finder_0_2_remove_xrl
01365        (const XrlCmdError &e,
01366         XrlRespCallback);
01367 #endif
01368 
01369     XrlCmdRT handle_finder_0_2_resolve_xrl(const XrlArgs& in, XrlCmdOT out);
01370 #ifdef XORP_ENABLE_ASYNC_SERVER
01371     void callback_finder_0_2_resolve_xrl
01372        (const XrlCmdError &e,
01373     const XrlAtomList* arg_resolutions,
01374         XrlRespCallback);
01375 #endif
01376 
01377     XrlCmdRT handle_finder_0_2_get_xrl_targets(const XrlArgs& in, XrlCmdOT out);
01378 #ifdef XORP_ENABLE_ASYNC_SERVER
01379     void callback_finder_0_2_get_xrl_targets
01380        (const XrlCmdError &e,
01381     const XrlAtomList* arg_target_names,
01382         XrlRespCallback);
01383 #endif
01384 
01385     XrlCmdRT handle_finder_0_2_get_xrls_registered_by(const XrlArgs& in, XrlCmdOT out);
01386 #ifdef XORP_ENABLE_ASYNC_SERVER
01387     void callback_finder_0_2_get_xrls_registered_by
01388        (const XrlCmdError &e,
01389     const XrlAtomList* arg_xrls,
01390         XrlRespCallback);
01391 #endif
01392 
01393     XrlCmdRT handle_finder_0_2_get_ipv4_permitted_hosts(const XrlArgs& in, XrlCmdOT out);
01394 #ifdef XORP_ENABLE_ASYNC_SERVER
01395     void callback_finder_0_2_get_ipv4_permitted_hosts
01396        (const XrlCmdError &e,
01397     const XrlAtomList* arg_ipv4s,
01398         XrlRespCallback);
01399 #endif
01400 
01401     XrlCmdRT handle_finder_0_2_get_ipv4_permitted_nets(const XrlArgs& in, XrlCmdOT out);
01402 #ifdef XORP_ENABLE_ASYNC_SERVER
01403     void callback_finder_0_2_get_ipv4_permitted_nets
01404        (const XrlCmdError &e,
01405     const XrlAtomList* arg_ipv4nets,
01406         XrlRespCallback);
01407 #endif
01408 
01409     XrlCmdRT handle_finder_0_2_get_ipv6_permitted_hosts(const XrlArgs& in, XrlCmdOT out);
01410 #ifdef XORP_ENABLE_ASYNC_SERVER
01411     void callback_finder_0_2_get_ipv6_permitted_hosts
01412        (const XrlCmdError &e,
01413     const XrlAtomList* arg_ipv6s,
01414         XrlRespCallback);
01415 #endif
01416 
01417     XrlCmdRT handle_finder_0_2_get_ipv6_permitted_nets(const XrlArgs& in, XrlCmdOT out);
01418 #ifdef XORP_ENABLE_ASYNC_SERVER
01419     void callback_finder_0_2_get_ipv6_permitted_nets
01420        (const XrlCmdError &e,
01421     const XrlAtomList* arg_ipv6nets,
01422         XrlRespCallback);
01423 #endif
01424 
01425     XrlCmdRT handle_finder_event_notifier_0_1_register_class_event_interest(const XrlArgs& in, XrlCmdOT out);
01426 #ifdef XORP_ENABLE_ASYNC_SERVER
01427     void callback_finder_event_notifier_0_1_register_class_event_interest
01428        (const XrlCmdError &e,
01429         XrlRespCallback);
01430 #endif
01431 
01432     XrlCmdRT handle_finder_event_notifier_0_1_deregister_class_event_interest(const XrlArgs& in, XrlCmdOT out);
01433 #ifdef XORP_ENABLE_ASYNC_SERVER
01434     void callback_finder_event_notifier_0_1_deregister_class_event_interest
01435        (const XrlCmdError &e,
01436         XrlRespCallback);
01437 #endif
01438 
01439     XrlCmdRT handle_finder_event_notifier_0_1_register_instance_event_interest(const XrlArgs& in, XrlCmdOT out);
01440 #ifdef XORP_ENABLE_ASYNC_SERVER
01441     void callback_finder_event_notifier_0_1_register_instance_event_interest
01442        (const XrlCmdError &e,
01443         XrlRespCallback);
01444 #endif
01445 
01446     XrlCmdRT handle_finder_event_notifier_0_1_deregister_instance_event_interest(const XrlArgs& in, XrlCmdOT out);
01447 #ifdef XORP_ENABLE_ASYNC_SERVER
01448     void callback_finder_event_notifier_0_1_deregister_instance_event_interest
01449        (const XrlCmdError &e,
01450         XrlRespCallback);
01451 #endif
01452 
01453     void add_handlers();
01454     void remove_handlers();
01455 
01456     struct handler_table {
01457         const char *name;
01458         XrlCmdRT (XrlFinderTargetBase::*method)(const XrlArgs&, XrlCmdOT);
01459     };
01460 
01461     static const struct handler_table handlers[];
01462     static const size_t num_handlers;
01463 };
01464 
01465 #endif // __XRL_TARGETS_FINDER_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations