static_routes_base.hh

/*
 * obj/i686-pc-linux-gnu/xrl/targets/static_routes_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_STATIC_ROUTES_BASE_HH__
#define __XRL_TARGETS_STATIC_ROUTES_BASE_HH__

#undef XORP_LIBRARY_NAME
#define XORP_LIBRARY_NAME "XrlStaticRoutesTarget"

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

class XrlStaticRoutesTargetBase {
protected:
    XrlCmdMap* _cmds;

public:
    XrlStaticRoutesTargetBase(XrlCmdMap* cmds = 0);

    virtual ~XrlStaticRoutesTargetBase();

    bool set_command_map(XrlCmdMap* cmds);

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

    const char* version() const { return "static_routes/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 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 static_routes_0_1_enable_static_routes(
    // Input values,
    const bool& enable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01EnableStaticRoutesRF;

    class StaticRoutes01EnableStaticRoutesCB {
        StaticRoutes01EnableStaticRoutesRF cb;

    public:
        operator const StaticRoutes01EnableStaticRoutesRF& () const { return cb; }
        const StaticRoutes01EnableStaticRoutesRF& operator ->() const { return cb; }
        StaticRoutes01EnableStaticRoutesCB(const StaticRoutes01EnableStaticRoutesRF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01EnableStaticRoutesRsp :
      public StaticRoutes01EnableStaticRoutesCB {
        StaticRoutes01EnableStaticRoutesRsp(const StaticRoutes01EnableStaticRoutesRF& cb)
          : StaticRoutes01EnableStaticRoutesCB(cb) { }

    };

    virtual void async_static_routes_0_1_enable_static_routes
       (
    const bool& enable,
    StaticRoutes01EnableStaticRoutesCB);
#endif

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

    class StaticRoutes01StartStaticRoutesCB {
        StaticRoutes01StartStaticRoutesRF cb;

    public:
        operator const StaticRoutes01StartStaticRoutesRF& () const { return cb; }
        const StaticRoutes01StartStaticRoutesRF& operator ->() const { return cb; }
        StaticRoutes01StartStaticRoutesCB(const StaticRoutes01StartStaticRoutesRF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01StartStaticRoutesRsp :
      public StaticRoutes01StartStaticRoutesCB {
        StaticRoutes01StartStaticRoutesRsp(const StaticRoutes01StartStaticRoutesRF& cb)
          : StaticRoutes01StartStaticRoutesCB(cb) { }

    };

    virtual void async_static_routes_0_1_start_static_routes
       (
    StaticRoutes01StartStaticRoutesCB);
#endif

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

    class StaticRoutes01StopStaticRoutesCB {
        StaticRoutes01StopStaticRoutesRF cb;

    public:
        operator const StaticRoutes01StopStaticRoutesRF& () const { return cb; }
        const StaticRoutes01StopStaticRoutesRF& operator ->() const { return cb; }
        StaticRoutes01StopStaticRoutesCB(const StaticRoutes01StopStaticRoutesRF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01StopStaticRoutesRsp :
      public StaticRoutes01StopStaticRoutesCB {
        StaticRoutes01StopStaticRoutesRsp(const StaticRoutes01StopStaticRoutesRF& cb)
          : StaticRoutes01StopStaticRoutesCB(cb) { }

    };

    virtual void async_static_routes_0_1_stop_static_routes
       (
    StaticRoutes01StopStaticRoutesCB);
#endif

    virtual XrlCmdError static_routes_0_1_add_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddRoute4RF;

    class StaticRoutes01AddRoute4CB {
        StaticRoutes01AddRoute4RF cb;

    public:
        operator const StaticRoutes01AddRoute4RF& () const { return cb; }
        const StaticRoutes01AddRoute4RF& operator ->() const { return cb; }
        StaticRoutes01AddRoute4CB(const StaticRoutes01AddRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddRoute4Rsp :
      public StaticRoutes01AddRoute4CB {
        StaticRoutes01AddRoute4Rsp(const StaticRoutes01AddRoute4RF& cb)
          : StaticRoutes01AddRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric,
    StaticRoutes01AddRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddRoute6RF;

    class StaticRoutes01AddRoute6CB {
        StaticRoutes01AddRoute6RF cb;

    public:
        operator const StaticRoutes01AddRoute6RF& () const { return cb; }
        const StaticRoutes01AddRoute6RF& operator ->() const { return cb; }
        StaticRoutes01AddRoute6CB(const StaticRoutes01AddRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddRoute6Rsp :
      public StaticRoutes01AddRoute6CB {
        StaticRoutes01AddRoute6Rsp(const StaticRoutes01AddRoute6RF& cb)
          : StaticRoutes01AddRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric,
    StaticRoutes01AddRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceRoute4RF;

    class StaticRoutes01ReplaceRoute4CB {
        StaticRoutes01ReplaceRoute4RF cb;

    public:
        operator const StaticRoutes01ReplaceRoute4RF& () const { return cb; }
        const StaticRoutes01ReplaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceRoute4CB(const StaticRoutes01ReplaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceRoute4Rsp :
      public StaticRoutes01ReplaceRoute4CB {
        StaticRoutes01ReplaceRoute4Rsp(const StaticRoutes01ReplaceRoute4RF& cb)
          : StaticRoutes01ReplaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric,
    StaticRoutes01ReplaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceRoute6RF;

    class StaticRoutes01ReplaceRoute6CB {
        StaticRoutes01ReplaceRoute6RF cb;

    public:
        operator const StaticRoutes01ReplaceRoute6RF& () const { return cb; }
        const StaticRoutes01ReplaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceRoute6CB(const StaticRoutes01ReplaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceRoute6Rsp :
      public StaticRoutes01ReplaceRoute6CB {
        StaticRoutes01ReplaceRoute6Rsp(const StaticRoutes01ReplaceRoute6RF& cb)
          : StaticRoutes01ReplaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric,
    StaticRoutes01ReplaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteRoute4RF;

    class StaticRoutes01DeleteRoute4CB {
        StaticRoutes01DeleteRoute4RF cb;

    public:
        operator const StaticRoutes01DeleteRoute4RF& () const { return cb; }
        const StaticRoutes01DeleteRoute4RF& operator ->() const { return cb; }
        StaticRoutes01DeleteRoute4CB(const StaticRoutes01DeleteRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteRoute4Rsp :
      public StaticRoutes01DeleteRoute4CB {
        StaticRoutes01DeleteRoute4Rsp(const StaticRoutes01DeleteRoute4RF& cb)
          : StaticRoutes01DeleteRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    StaticRoutes01DeleteRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteRoute6RF;

    class StaticRoutes01DeleteRoute6CB {
        StaticRoutes01DeleteRoute6RF cb;

    public:
        operator const StaticRoutes01DeleteRoute6RF& () const { return cb; }
        const StaticRoutes01DeleteRoute6RF& operator ->() const { return cb; }
        StaticRoutes01DeleteRoute6CB(const StaticRoutes01DeleteRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteRoute6Rsp :
      public StaticRoutes01DeleteRoute6CB {
        StaticRoutes01DeleteRoute6Rsp(const StaticRoutes01DeleteRoute6RF& cb)
          : StaticRoutes01DeleteRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    StaticRoutes01DeleteRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_backup_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddBackupRoute4RF;

    class StaticRoutes01AddBackupRoute4CB {
        StaticRoutes01AddBackupRoute4RF cb;

    public:
        operator const StaticRoutes01AddBackupRoute4RF& () const { return cb; }
        const StaticRoutes01AddBackupRoute4RF& operator ->() const { return cb; }
        StaticRoutes01AddBackupRoute4CB(const StaticRoutes01AddBackupRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddBackupRoute4Rsp :
      public StaticRoutes01AddBackupRoute4CB {
        StaticRoutes01AddBackupRoute4Rsp(const StaticRoutes01AddBackupRoute4RF& cb)
          : StaticRoutes01AddBackupRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_backup_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric,
    StaticRoutes01AddBackupRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_backup_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddBackupRoute6RF;

    class StaticRoutes01AddBackupRoute6CB {
        StaticRoutes01AddBackupRoute6RF cb;

    public:
        operator const StaticRoutes01AddBackupRoute6RF& () const { return cb; }
        const StaticRoutes01AddBackupRoute6RF& operator ->() const { return cb; }
        StaticRoutes01AddBackupRoute6CB(const StaticRoutes01AddBackupRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddBackupRoute6Rsp :
      public StaticRoutes01AddBackupRoute6CB {
        StaticRoutes01AddBackupRoute6Rsp(const StaticRoutes01AddBackupRoute6RF& cb)
          : StaticRoutes01AddBackupRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_backup_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric,
    StaticRoutes01AddBackupRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_backup_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceBackupRoute4RF;

    class StaticRoutes01ReplaceBackupRoute4CB {
        StaticRoutes01ReplaceBackupRoute4RF cb;

    public:
        operator const StaticRoutes01ReplaceBackupRoute4RF& () const { return cb; }
        const StaticRoutes01ReplaceBackupRoute4RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceBackupRoute4CB(const StaticRoutes01ReplaceBackupRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceBackupRoute4Rsp :
      public StaticRoutes01ReplaceBackupRoute4CB {
        StaticRoutes01ReplaceBackupRoute4Rsp(const StaticRoutes01ReplaceBackupRoute4RF& cb)
          : StaticRoutes01ReplaceBackupRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_backup_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const uint32_t& metric,
    StaticRoutes01ReplaceBackupRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_backup_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceBackupRoute6RF;

    class StaticRoutes01ReplaceBackupRoute6CB {
        StaticRoutes01ReplaceBackupRoute6RF cb;

    public:
        operator const StaticRoutes01ReplaceBackupRoute6RF& () const { return cb; }
        const StaticRoutes01ReplaceBackupRoute6RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceBackupRoute6CB(const StaticRoutes01ReplaceBackupRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceBackupRoute6Rsp :
      public StaticRoutes01ReplaceBackupRoute6CB {
        StaticRoutes01ReplaceBackupRoute6Rsp(const StaticRoutes01ReplaceBackupRoute6RF& cb)
          : StaticRoutes01ReplaceBackupRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_backup_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const uint32_t& metric,
    StaticRoutes01ReplaceBackupRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_backup_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteBackupRoute4RF;

    class StaticRoutes01DeleteBackupRoute4CB {
        StaticRoutes01DeleteBackupRoute4RF cb;

    public:
        operator const StaticRoutes01DeleteBackupRoute4RF& () const { return cb; }
        const StaticRoutes01DeleteBackupRoute4RF& operator ->() const { return cb; }
        StaticRoutes01DeleteBackupRoute4CB(const StaticRoutes01DeleteBackupRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteBackupRoute4Rsp :
      public StaticRoutes01DeleteBackupRoute4CB {
        StaticRoutes01DeleteBackupRoute4Rsp(const StaticRoutes01DeleteBackupRoute4RF& cb)
          : StaticRoutes01DeleteBackupRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_backup_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    StaticRoutes01DeleteBackupRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_backup_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteBackupRoute6RF;

    class StaticRoutes01DeleteBackupRoute6CB {
        StaticRoutes01DeleteBackupRoute6RF cb;

    public:
        operator const StaticRoutes01DeleteBackupRoute6RF& () const { return cb; }
        const StaticRoutes01DeleteBackupRoute6RF& operator ->() const { return cb; }
        StaticRoutes01DeleteBackupRoute6CB(const StaticRoutes01DeleteBackupRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteBackupRoute6Rsp :
      public StaticRoutes01DeleteBackupRoute6CB {
        StaticRoutes01DeleteBackupRoute6Rsp(const StaticRoutes01DeleteBackupRoute6RF& cb)
          : StaticRoutes01DeleteBackupRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_backup_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    StaticRoutes01DeleteBackupRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddInterfaceRoute4RF;

    class StaticRoutes01AddInterfaceRoute4CB {
        StaticRoutes01AddInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01AddInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01AddInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01AddInterfaceRoute4CB(const StaticRoutes01AddInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddInterfaceRoute4Rsp :
      public StaticRoutes01AddInterfaceRoute4CB {
        StaticRoutes01AddInterfaceRoute4Rsp(const StaticRoutes01AddInterfaceRoute4RF& cb)
          : StaticRoutes01AddInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01AddInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddInterfaceRoute6RF;

    class StaticRoutes01AddInterfaceRoute6CB {
        StaticRoutes01AddInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01AddInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01AddInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01AddInterfaceRoute6CB(const StaticRoutes01AddInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddInterfaceRoute6Rsp :
      public StaticRoutes01AddInterfaceRoute6CB {
        StaticRoutes01AddInterfaceRoute6Rsp(const StaticRoutes01AddInterfaceRoute6RF& cb)
          : StaticRoutes01AddInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01AddInterfaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceInterfaceRoute4RF;

    class StaticRoutes01ReplaceInterfaceRoute4CB {
        StaticRoutes01ReplaceInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01ReplaceInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01ReplaceInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceInterfaceRoute4CB(const StaticRoutes01ReplaceInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceInterfaceRoute4Rsp :
      public StaticRoutes01ReplaceInterfaceRoute4CB {
        StaticRoutes01ReplaceInterfaceRoute4Rsp(const StaticRoutes01ReplaceInterfaceRoute4RF& cb)
          : StaticRoutes01ReplaceInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01ReplaceInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceInterfaceRoute6RF;

    class StaticRoutes01ReplaceInterfaceRoute6CB {
        StaticRoutes01ReplaceInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01ReplaceInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01ReplaceInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceInterfaceRoute6CB(const StaticRoutes01ReplaceInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceInterfaceRoute6Rsp :
      public StaticRoutes01ReplaceInterfaceRoute6CB {
        StaticRoutes01ReplaceInterfaceRoute6Rsp(const StaticRoutes01ReplaceInterfaceRoute6RF& cb)
          : StaticRoutes01ReplaceInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01ReplaceInterfaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteInterfaceRoute4RF;

    class StaticRoutes01DeleteInterfaceRoute4CB {
        StaticRoutes01DeleteInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01DeleteInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01DeleteInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01DeleteInterfaceRoute4CB(const StaticRoutes01DeleteInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteInterfaceRoute4Rsp :
      public StaticRoutes01DeleteInterfaceRoute4CB {
        StaticRoutes01DeleteInterfaceRoute4Rsp(const StaticRoutes01DeleteInterfaceRoute4RF& cb)
          : StaticRoutes01DeleteInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    StaticRoutes01DeleteInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteInterfaceRoute6RF;

    class StaticRoutes01DeleteInterfaceRoute6CB {
        StaticRoutes01DeleteInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01DeleteInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01DeleteInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01DeleteInterfaceRoute6CB(const StaticRoutes01DeleteInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteInterfaceRoute6Rsp :
      public StaticRoutes01DeleteInterfaceRoute6CB {
        StaticRoutes01DeleteInterfaceRoute6Rsp(const StaticRoutes01DeleteInterfaceRoute6RF& cb)
          : StaticRoutes01DeleteInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    StaticRoutes01DeleteInterfaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_backup_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddBackupInterfaceRoute4RF;

    class StaticRoutes01AddBackupInterfaceRoute4CB {
        StaticRoutes01AddBackupInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01AddBackupInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01AddBackupInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01AddBackupInterfaceRoute4CB(const StaticRoutes01AddBackupInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddBackupInterfaceRoute4Rsp :
      public StaticRoutes01AddBackupInterfaceRoute4CB {
        StaticRoutes01AddBackupInterfaceRoute4Rsp(const StaticRoutes01AddBackupInterfaceRoute4RF& cb)
          : StaticRoutes01AddBackupInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_backup_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01AddBackupInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_add_backup_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01AddBackupInterfaceRoute6RF;

    class StaticRoutes01AddBackupInterfaceRoute6CB {
        StaticRoutes01AddBackupInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01AddBackupInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01AddBackupInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01AddBackupInterfaceRoute6CB(const StaticRoutes01AddBackupInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01AddBackupInterfaceRoute6Rsp :
      public StaticRoutes01AddBackupInterfaceRoute6CB {
        StaticRoutes01AddBackupInterfaceRoute6Rsp(const StaticRoutes01AddBackupInterfaceRoute6RF& cb)
          : StaticRoutes01AddBackupInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_add_backup_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01AddBackupInterfaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_backup_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceBackupInterfaceRoute4RF;

    class StaticRoutes01ReplaceBackupInterfaceRoute4CB {
        StaticRoutes01ReplaceBackupInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01ReplaceBackupInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01ReplaceBackupInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceBackupInterfaceRoute4CB(const StaticRoutes01ReplaceBackupInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceBackupInterfaceRoute4Rsp :
      public StaticRoutes01ReplaceBackupInterfaceRoute4CB {
        StaticRoutes01ReplaceBackupInterfaceRoute4Rsp(const StaticRoutes01ReplaceBackupInterfaceRoute4RF& cb)
          : StaticRoutes01ReplaceBackupInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_backup_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01ReplaceBackupInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_replace_backup_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01ReplaceBackupInterfaceRoute6RF;

    class StaticRoutes01ReplaceBackupInterfaceRoute6CB {
        StaticRoutes01ReplaceBackupInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01ReplaceBackupInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01ReplaceBackupInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01ReplaceBackupInterfaceRoute6CB(const StaticRoutes01ReplaceBackupInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01ReplaceBackupInterfaceRoute6Rsp :
      public StaticRoutes01ReplaceBackupInterfaceRoute6CB {
        StaticRoutes01ReplaceBackupInterfaceRoute6Rsp(const StaticRoutes01ReplaceBackupInterfaceRoute6RF& cb)
          : StaticRoutes01ReplaceBackupInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_replace_backup_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& metric,
    StaticRoutes01ReplaceBackupInterfaceRoute6CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_backup_interface_route4(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteBackupInterfaceRoute4RF;

    class StaticRoutes01DeleteBackupInterfaceRoute4CB {
        StaticRoutes01DeleteBackupInterfaceRoute4RF cb;

    public:
        operator const StaticRoutes01DeleteBackupInterfaceRoute4RF& () const { return cb; }
        const StaticRoutes01DeleteBackupInterfaceRoute4RF& operator ->() const { return cb; }
        StaticRoutes01DeleteBackupInterfaceRoute4CB(const StaticRoutes01DeleteBackupInterfaceRoute4RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteBackupInterfaceRoute4Rsp :
      public StaticRoutes01DeleteBackupInterfaceRoute4CB {
        StaticRoutes01DeleteBackupInterfaceRoute4Rsp(const StaticRoutes01DeleteBackupInterfaceRoute4RF& cb)
          : StaticRoutes01DeleteBackupInterfaceRoute4CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_backup_interface_route4
       (
    const bool& unicast,
    const bool& multicast,
    const IPv4Net&  network,
    const IPv4& nexthop,
    const string&   ifname,
    const string&   vifname,
    StaticRoutes01DeleteBackupInterfaceRoute4CB);
#endif

    virtual XrlCmdError static_routes_0_1_delete_backup_interface_route6(
    // Input values,
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    StaticRoutes01DeleteBackupInterfaceRoute6RF;

    class StaticRoutes01DeleteBackupInterfaceRoute6CB {
        StaticRoutes01DeleteBackupInterfaceRoute6RF cb;

    public:
        operator const StaticRoutes01DeleteBackupInterfaceRoute6RF& () const { return cb; }
        const StaticRoutes01DeleteBackupInterfaceRoute6RF& operator ->() const { return cb; }
        StaticRoutes01DeleteBackupInterfaceRoute6CB(const StaticRoutes01DeleteBackupInterfaceRoute6RF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01DeleteBackupInterfaceRoute6Rsp :
      public StaticRoutes01DeleteBackupInterfaceRoute6CB {
        StaticRoutes01DeleteBackupInterfaceRoute6Rsp(const StaticRoutes01DeleteBackupInterfaceRoute6RF& cb)
          : StaticRoutes01DeleteBackupInterfaceRoute6CB(cb) { }

    };

    virtual void async_static_routes_0_1_delete_backup_interface_route6
       (
    const bool& unicast,
    const bool& multicast,
    const IPv6Net&  network,
    const IPv6& nexthop,
    const string&   ifname,
    const string&   vifname,
    StaticRoutes01DeleteBackupInterfaceRoute6CB);
#endif

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

    class StaticRoutes01EnableLogTraceAllCB {
        StaticRoutes01EnableLogTraceAllRF cb;

    public:
        operator const StaticRoutes01EnableLogTraceAllRF& () const { return cb; }
        const StaticRoutes01EnableLogTraceAllRF& operator ->() const { return cb; }
        StaticRoutes01EnableLogTraceAllCB(const StaticRoutes01EnableLogTraceAllRF& cb)
          : cb(cb) { }

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

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

    struct StaticRoutes01EnableLogTraceAllRsp :
      public StaticRoutes01EnableLogTraceAllCB {
        StaticRoutes01EnableLogTraceAllRsp(const StaticRoutes01EnableLogTraceAllRF& cb)
          : StaticRoutes01EnableLogTraceAllCB(cb) { }

    };

    virtual void async_static_routes_0_1_enable_log_trace_all
       (
    const bool& enable,
    StaticRoutes01EnableLogTraceAllCB);
#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_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_static_routes_0_1_enable_static_routes(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_static_routes_0_1_enable_static_routes
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void add_handlers();
    void remove_handlers();

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

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

#endif // __XRL_TARGETS_STATIC_ROUTES_BASE_HH__