fib2mrib_base.hh

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


#ifndef __XRL_TARGETS_FIB2MRIB_BASE_HH__
#define __XRL_TARGETS_FIB2MRIB_BASE_HH__

#undef XORP_LIBRARY_NAME
#define XORP_LIBRARY_NAME "XrlFib2mribTarget"

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

class XrlFib2mribTargetBase {
protected:
    XrlCmdMap* _cmds;

public:
    XrlFib2mribTargetBase(XrlCmdMap* cmds = 0);

    virtual ~XrlFib2mribTargetBase();

    bool set_command_map(XrlCmdMap* cmds);

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

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

protected:

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

    class Common01GetTargetNameCB {
        Common01GetTargetNameRF cb;

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

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

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

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

    private:
        args_str args;

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

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

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

    virtual void async_common_0_1_get_target_name
       (
    Common01GetTargetNameCB);
#endif

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

    class Common01GetVersionCB {
        Common01GetVersionRF cb;

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

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

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

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

    private:
        args_str args;

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

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

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

    virtual void async_common_0_1_get_version
       (
    Common01GetVersionCB);
#endif

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

    class Common01GetStatusCB {
        Common01GetStatusRF cb;

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

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

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

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

    private:
        args_str args;

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

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

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

    virtual void async_common_0_1_get_status
       (
    Common01GetStatusCB);
#endif

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

    class Common01ShutdownCB {
        Common01ShutdownRF cb;

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

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

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

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

    };

    virtual void async_common_0_1_shutdown
       (
    Common01ShutdownCB);
#endif

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

    class Common01StartupCB {
        Common01StartupRF cb;

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

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

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

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

    };

    virtual void async_common_0_1_startup
       (
    Common01StartupCB);
#endif

    virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
    // Input values,
    const string&   target_class,
    const string&   target_instance) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FinderEventObserver01XrlTargetBirthRF;

    class FinderEventObserver01XrlTargetBirthCB {
        FinderEventObserver01XrlTargetBirthRF cb;

    public:
        operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
        const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
        FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
          : cb(cb) { }

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

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

    struct FinderEventObserver01XrlTargetBirthRsp :
      public FinderEventObserver01XrlTargetBirthCB {
        FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
          : FinderEventObserver01XrlTargetBirthCB(cb) { }

    };

    virtual void async_finder_event_observer_0_1_xrl_target_birth
       (
    const string&   target_class,
    const string&   target_instance,
    FinderEventObserver01XrlTargetBirthCB);
#endif

    virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
    // Input values,
    const string&   target_class,
    const string&   target_instance) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FinderEventObserver01XrlTargetDeathRF;

    class FinderEventObserver01XrlTargetDeathCB {
        FinderEventObserver01XrlTargetDeathRF cb;

    public:
        operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
        const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
        FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
          : cb(cb) { }

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

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

    struct FinderEventObserver01XrlTargetDeathRsp :
      public FinderEventObserver01XrlTargetDeathCB {
        FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
          : FinderEventObserver01XrlTargetDeathCB(cb) { }

    };

    virtual void async_finder_event_observer_0_1_xrl_target_death
       (
    const string&   target_class,
    const string&   target_instance,
    FinderEventObserver01XrlTargetDeathCB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_add_route4(
    // Input values,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01AddRoute4RF;

    class FeaFibClient01AddRoute4CB {
        FeaFibClient01AddRoute4RF cb;

    public:
        operator const FeaFibClient01AddRoute4RF& () const { return cb; }
        const FeaFibClient01AddRoute4RF& operator ->() const { return cb; }
        FeaFibClient01AddRoute4CB(const FeaFibClient01AddRoute4RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01AddRoute4Rsp :
      public FeaFibClient01AddRoute4CB {
        FeaFibClient01AddRoute4Rsp(const FeaFibClient01AddRoute4RF& cb)
          : FeaFibClient01AddRoute4CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_add_route4
       (
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route,
    FeaFibClient01AddRoute4CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_replace_route4(
    // Input values,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01ReplaceRoute4RF;

    class FeaFibClient01ReplaceRoute4CB {
        FeaFibClient01ReplaceRoute4RF cb;

    public:
        operator const FeaFibClient01ReplaceRoute4RF& () const { return cb; }
        const FeaFibClient01ReplaceRoute4RF& operator ->() const { return cb; }
        FeaFibClient01ReplaceRoute4CB(const FeaFibClient01ReplaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01ReplaceRoute4Rsp :
      public FeaFibClient01ReplaceRoute4CB {
        FeaFibClient01ReplaceRoute4Rsp(const FeaFibClient01ReplaceRoute4RF& cb)
          : FeaFibClient01ReplaceRoute4CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_replace_route4
       (
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route,
    FeaFibClient01ReplaceRoute4CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_delete_route4(
    // Input values,
    const IPv4Net&  network,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01DeleteRoute4RF;

    class FeaFibClient01DeleteRoute4CB {
        FeaFibClient01DeleteRoute4RF cb;

    public:
        operator const FeaFibClient01DeleteRoute4RF& () const { return cb; }
        const FeaFibClient01DeleteRoute4RF& operator ->() const { return cb; }
        FeaFibClient01DeleteRoute4CB(const FeaFibClient01DeleteRoute4RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01DeleteRoute4Rsp :
      public FeaFibClient01DeleteRoute4CB {
        FeaFibClient01DeleteRoute4Rsp(const FeaFibClient01DeleteRoute4RF& cb)
          : FeaFibClient01DeleteRoute4CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_delete_route4
       (
    const IPv4Net&  network,
    const string&   ifname,
    const string&   vifname,
    FeaFibClient01DeleteRoute4CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_resolve_route4(
    // Input values,
    const IPv4Net&  network) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01ResolveRoute4RF;

    class FeaFibClient01ResolveRoute4CB {
        FeaFibClient01ResolveRoute4RF cb;

    public:
        operator const FeaFibClient01ResolveRoute4RF& () const { return cb; }
        const FeaFibClient01ResolveRoute4RF& operator ->() const { return cb; }
        FeaFibClient01ResolveRoute4CB(const FeaFibClient01ResolveRoute4RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01ResolveRoute4Rsp :
      public FeaFibClient01ResolveRoute4CB {
        FeaFibClient01ResolveRoute4Rsp(const FeaFibClient01ResolveRoute4RF& cb)
          : FeaFibClient01ResolveRoute4CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_resolve_route4
       (
    const IPv4Net&  network,
    FeaFibClient01ResolveRoute4CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_add_route6(
    // Input values,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01AddRoute6RF;

    class FeaFibClient01AddRoute6CB {
        FeaFibClient01AddRoute6RF cb;

    public:
        operator const FeaFibClient01AddRoute6RF& () const { return cb; }
        const FeaFibClient01AddRoute6RF& operator ->() const { return cb; }
        FeaFibClient01AddRoute6CB(const FeaFibClient01AddRoute6RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01AddRoute6Rsp :
      public FeaFibClient01AddRoute6CB {
        FeaFibClient01AddRoute6Rsp(const FeaFibClient01AddRoute6RF& cb)
          : FeaFibClient01AddRoute6CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_add_route6
       (
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route,
    FeaFibClient01AddRoute6CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_resolve_route6(
    // Input values,
    const IPv6Net&  network) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01ResolveRoute6RF;

    class FeaFibClient01ResolveRoute6CB {
        FeaFibClient01ResolveRoute6RF cb;

    public:
        operator const FeaFibClient01ResolveRoute6RF& () const { return cb; }
        const FeaFibClient01ResolveRoute6RF& operator ->() const { return cb; }
        FeaFibClient01ResolveRoute6CB(const FeaFibClient01ResolveRoute6RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01ResolveRoute6Rsp :
      public FeaFibClient01ResolveRoute6CB {
        FeaFibClient01ResolveRoute6Rsp(const FeaFibClient01ResolveRoute6RF& cb)
          : FeaFibClient01ResolveRoute6CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_resolve_route6
       (
    const IPv6Net&  network,
    FeaFibClient01ResolveRoute6CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_replace_route6(
    // Input values,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01ReplaceRoute6RF;

    class FeaFibClient01ReplaceRoute6CB {
        FeaFibClient01ReplaceRoute6RF cb;

    public:
        operator const FeaFibClient01ReplaceRoute6RF& () const { return cb; }
        const FeaFibClient01ReplaceRoute6RF& operator ->() const { return cb; }
        FeaFibClient01ReplaceRoute6CB(const FeaFibClient01ReplaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01ReplaceRoute6Rsp :
      public FeaFibClient01ReplaceRoute6CB {
        FeaFibClient01ReplaceRoute6Rsp(const FeaFibClient01ReplaceRoute6RF& cb)
          : FeaFibClient01ReplaceRoute6CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_replace_route6
       (
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    const uint32_t& admin_distance,
    const string&   protocol_origin,
    const bool& xorp_route,
    FeaFibClient01ReplaceRoute6CB);
#endif

    virtual XrlCmdError fea_fib_client_0_1_delete_route6(
    // Input values,
    const IPv6Net&  network,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaFibClient01DeleteRoute6RF;

    class FeaFibClient01DeleteRoute6CB {
        FeaFibClient01DeleteRoute6RF cb;

    public:
        operator const FeaFibClient01DeleteRoute6RF& () const { return cb; }
        const FeaFibClient01DeleteRoute6RF& operator ->() const { return cb; }
        FeaFibClient01DeleteRoute6CB(const FeaFibClient01DeleteRoute6RF& cb)
          : cb(cb) { }

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

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

    struct FeaFibClient01DeleteRoute6Rsp :
      public FeaFibClient01DeleteRoute6CB {
        FeaFibClient01DeleteRoute6Rsp(const FeaFibClient01DeleteRoute6RF& cb)
          : FeaFibClient01DeleteRoute6CB(cb) { }

    };

    virtual void async_fea_fib_client_0_1_delete_route6
       (
    const IPv6Net&  network,
    const string&   ifname,
    const string&   vifname,
    FeaFibClient01DeleteRoute6CB);
#endif

    virtual XrlCmdError policy_backend_0_1_configure(
    // Input values,
    const uint32_t& filter,
    const string&   conf) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    PolicyBackend01ConfigureRF;

    class PolicyBackend01ConfigureCB {
        PolicyBackend01ConfigureRF cb;

    public:
        operator const PolicyBackend01ConfigureRF& () const { return cb; }
        const PolicyBackend01ConfigureRF& operator ->() const { return cb; }
        PolicyBackend01ConfigureCB(const PolicyBackend01ConfigureRF& cb)
          : cb(cb) { }

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

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

    struct PolicyBackend01ConfigureRsp :
      public PolicyBackend01ConfigureCB {
        PolicyBackend01ConfigureRsp(const PolicyBackend01ConfigureRF& cb)
          : PolicyBackend01ConfigureCB(cb) { }

    };

    virtual void async_policy_backend_0_1_configure
       (
    const uint32_t& filter,
    const string&   conf,
    PolicyBackend01ConfigureCB);
#endif

    virtual XrlCmdError policy_backend_0_1_reset(
    // Input values,
    const uint32_t& filter) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    PolicyBackend01ResetRF;

    class PolicyBackend01ResetCB {
        PolicyBackend01ResetRF cb;

    public:
        operator const PolicyBackend01ResetRF& () const { return cb; }
        const PolicyBackend01ResetRF& operator ->() const { return cb; }
        PolicyBackend01ResetCB(const PolicyBackend01ResetRF& cb)
          : cb(cb) { }

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

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

    struct PolicyBackend01ResetRsp :
      public PolicyBackend01ResetCB {
        PolicyBackend01ResetRsp(const PolicyBackend01ResetRF& cb)
          : PolicyBackend01ResetCB(cb) { }

    };

    virtual void async_policy_backend_0_1_reset
       (
    const uint32_t& filter,
    PolicyBackend01ResetCB);
#endif

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

    class PolicyBackend01PushRoutesCB {
        PolicyBackend01PushRoutesRF cb;

    public:
        operator const PolicyBackend01PushRoutesRF& () const { return cb; }
        const PolicyBackend01PushRoutesRF& operator ->() const { return cb; }
        PolicyBackend01PushRoutesCB(const PolicyBackend01PushRoutesRF& cb)
          : cb(cb) { }

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

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

    struct PolicyBackend01PushRoutesRsp :
      public PolicyBackend01PushRoutesCB {
        PolicyBackend01PushRoutesRsp(const PolicyBackend01PushRoutesRF& cb)
          : PolicyBackend01PushRoutesCB(cb) { }

    };

    virtual void async_policy_backend_0_1_push_routes
       (
    PolicyBackend01PushRoutesCB);
#endif

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

    class Fib2Mrib01EnableFib2MribCB {
        Fib2Mrib01EnableFib2MribRF cb;

    public:
        operator const Fib2Mrib01EnableFib2MribRF& () const { return cb; }
        const Fib2Mrib01EnableFib2MribRF& operator ->() const { return cb; }
        Fib2Mrib01EnableFib2MribCB(const Fib2Mrib01EnableFib2MribRF& cb)
          : cb(cb) { }

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

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

    struct Fib2Mrib01EnableFib2MribRsp :
      public Fib2Mrib01EnableFib2MribCB {
        Fib2Mrib01EnableFib2MribRsp(const Fib2Mrib01EnableFib2MribRF& cb)
          : Fib2Mrib01EnableFib2MribCB(cb) { }

    };

    virtual void async_fib2mrib_0_1_enable_fib2mrib
       (
    const bool& enable,
    Fib2Mrib01EnableFib2MribCB);
#endif

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

    class Fib2Mrib01StartFib2MribCB {
        Fib2Mrib01StartFib2MribRF cb;

    public:
        operator const Fib2Mrib01StartFib2MribRF& () const { return cb; }
        const Fib2Mrib01StartFib2MribRF& operator ->() const { return cb; }
        Fib2Mrib01StartFib2MribCB(const Fib2Mrib01StartFib2MribRF& cb)
          : cb(cb) { }

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

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

    struct Fib2Mrib01StartFib2MribRsp :
      public Fib2Mrib01StartFib2MribCB {
        Fib2Mrib01StartFib2MribRsp(const Fib2Mrib01StartFib2MribRF& cb)
          : Fib2Mrib01StartFib2MribCB(cb) { }

    };

    virtual void async_fib2mrib_0_1_start_fib2mrib
       (
    Fib2Mrib01StartFib2MribCB);
#endif

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

    class Fib2Mrib01StopFib2MribCB {
        Fib2Mrib01StopFib2MribRF cb;

    public:
        operator const Fib2Mrib01StopFib2MribRF& () const { return cb; }
        const Fib2Mrib01StopFib2MribRF& operator ->() const { return cb; }
        Fib2Mrib01StopFib2MribCB(const Fib2Mrib01StopFib2MribRF& cb)
          : cb(cb) { }

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

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

    struct Fib2Mrib01StopFib2MribRsp :
      public Fib2Mrib01StopFib2MribCB {
        Fib2Mrib01StopFib2MribRsp(const Fib2Mrib01StopFib2MribRF& cb)
          : Fib2Mrib01StopFib2MribCB(cb) { }

    };

    virtual void async_fib2mrib_0_1_stop_fib2mrib
       (
    Fib2Mrib01StopFib2MribCB);
#endif

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

    class Fib2Mrib01EnableLogTraceAllCB {
        Fib2Mrib01EnableLogTraceAllRF cb;

    public:
        operator const Fib2Mrib01EnableLogTraceAllRF& () const { return cb; }
        const Fib2Mrib01EnableLogTraceAllRF& operator ->() const { return cb; }
        Fib2Mrib01EnableLogTraceAllCB(const Fib2Mrib01EnableLogTraceAllRF& cb)
          : cb(cb) { }

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

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

    struct Fib2Mrib01EnableLogTraceAllRsp :
      public Fib2Mrib01EnableLogTraceAllCB {
        Fib2Mrib01EnableLogTraceAllRsp(const Fib2Mrib01EnableLogTraceAllRF& cb)
          : Fib2Mrib01EnableLogTraceAllCB(cb) { }

    };

    virtual void async_fib2mrib_0_1_enable_log_trace_all
       (
    const bool& enable,
    Fib2Mrib01EnableLogTraceAllCB);
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void add_handlers();
    void remove_handlers();

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

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

#endif // __XRL_TARGETS_FIB2MRIB_BASE_HH__