fea_ifmgr_mirror_base.hh

/*
 * obj/i686-pc-linux-gnu/xrl/targets/fea_ifmgr_mirror_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_FEA_IFMGR_MIRROR_BASE_HH__
#define __XRL_TARGETS_FEA_IFMGR_MIRROR_BASE_HH__

#undef XORP_LIBRARY_NAME
#define XORP_LIBRARY_NAME "XrlFeaIfmgrMirrorTarget"

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

class XrlFeaIfmgrMirrorTargetBase {
protected:
    XrlCmdMap* _cmds;

public:
    XrlFeaIfmgrMirrorTargetBase(XrlCmdMap* cmds = 0);

    virtual ~XrlFeaIfmgrMirrorTargetBase();

    bool set_command_map(XrlCmdMap* cmds);

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

    const char* version() const { return "fea_ifmgr_mirror/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 fea_ifmgr_mirror_0_1_interface_add(
    // Input values,
    const string&   ifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceAddRF;

    class FeaIfmgrMirror01InterfaceAddCB {
        FeaIfmgrMirror01InterfaceAddRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceAddRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceAddRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceAddCB(const FeaIfmgrMirror01InterfaceAddRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceAddRsp :
      public FeaIfmgrMirror01InterfaceAddCB {
        FeaIfmgrMirror01InterfaceAddRsp(const FeaIfmgrMirror01InterfaceAddRF& cb)
          : FeaIfmgrMirror01InterfaceAddCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_add
       (
    const string&   ifname,
    FeaIfmgrMirror01InterfaceAddCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_remove(
    // Input values,
    const string&   ifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceRemoveRF;

    class FeaIfmgrMirror01InterfaceRemoveCB {
        FeaIfmgrMirror01InterfaceRemoveRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceRemoveRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceRemoveRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceRemoveCB(const FeaIfmgrMirror01InterfaceRemoveRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceRemoveRsp :
      public FeaIfmgrMirror01InterfaceRemoveCB {
        FeaIfmgrMirror01InterfaceRemoveRsp(const FeaIfmgrMirror01InterfaceRemoveRF& cb)
          : FeaIfmgrMirror01InterfaceRemoveCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_remove
       (
    const string&   ifname,
    FeaIfmgrMirror01InterfaceRemoveCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_enabled(
    // Input values,
    const string&   ifname,
    const bool& enabled) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetEnabledRF;

    class FeaIfmgrMirror01InterfaceSetEnabledCB {
        FeaIfmgrMirror01InterfaceSetEnabledRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetEnabledRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetEnabledRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetEnabledCB(const FeaIfmgrMirror01InterfaceSetEnabledRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetEnabledRsp :
      public FeaIfmgrMirror01InterfaceSetEnabledCB {
        FeaIfmgrMirror01InterfaceSetEnabledRsp(const FeaIfmgrMirror01InterfaceSetEnabledRF& cb)
          : FeaIfmgrMirror01InterfaceSetEnabledCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_enabled
       (
    const string&   ifname,
    const bool& enabled,
    FeaIfmgrMirror01InterfaceSetEnabledCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_discard(
    // Input values,
    const string&   ifname,
    const bool& discard) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetDiscardRF;

    class FeaIfmgrMirror01InterfaceSetDiscardCB {
        FeaIfmgrMirror01InterfaceSetDiscardRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetDiscardRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetDiscardRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetDiscardCB(const FeaIfmgrMirror01InterfaceSetDiscardRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetDiscardRsp :
      public FeaIfmgrMirror01InterfaceSetDiscardCB {
        FeaIfmgrMirror01InterfaceSetDiscardRsp(const FeaIfmgrMirror01InterfaceSetDiscardRF& cb)
          : FeaIfmgrMirror01InterfaceSetDiscardCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_discard
       (
    const string&   ifname,
    const bool& discard,
    FeaIfmgrMirror01InterfaceSetDiscardCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_unreachable(
    // Input values,
    const string&   ifname,
    const bool& unreachable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetUnreachableRF;

    class FeaIfmgrMirror01InterfaceSetUnreachableCB {
        FeaIfmgrMirror01InterfaceSetUnreachableRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetUnreachableRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetUnreachableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetUnreachableCB(const FeaIfmgrMirror01InterfaceSetUnreachableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetUnreachableRsp :
      public FeaIfmgrMirror01InterfaceSetUnreachableCB {
        FeaIfmgrMirror01InterfaceSetUnreachableRsp(const FeaIfmgrMirror01InterfaceSetUnreachableRF& cb)
          : FeaIfmgrMirror01InterfaceSetUnreachableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_unreachable
       (
    const string&   ifname,
    const bool& unreachable,
    FeaIfmgrMirror01InterfaceSetUnreachableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_management(
    // Input values,
    const string&   ifname,
    const bool& management) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetManagementRF;

    class FeaIfmgrMirror01InterfaceSetManagementCB {
        FeaIfmgrMirror01InterfaceSetManagementRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetManagementRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetManagementRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetManagementCB(const FeaIfmgrMirror01InterfaceSetManagementRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetManagementRsp :
      public FeaIfmgrMirror01InterfaceSetManagementCB {
        FeaIfmgrMirror01InterfaceSetManagementRsp(const FeaIfmgrMirror01InterfaceSetManagementRF& cb)
          : FeaIfmgrMirror01InterfaceSetManagementCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_management
       (
    const string&   ifname,
    const bool& management,
    FeaIfmgrMirror01InterfaceSetManagementCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_mtu(
    // Input values,
    const string&   ifname,
    const uint32_t& mtu) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetMtuRF;

    class FeaIfmgrMirror01InterfaceSetMtuCB {
        FeaIfmgrMirror01InterfaceSetMtuRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetMtuRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetMtuRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetMtuCB(const FeaIfmgrMirror01InterfaceSetMtuRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetMtuRsp :
      public FeaIfmgrMirror01InterfaceSetMtuCB {
        FeaIfmgrMirror01InterfaceSetMtuRsp(const FeaIfmgrMirror01InterfaceSetMtuRF& cb)
          : FeaIfmgrMirror01InterfaceSetMtuCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_mtu
       (
    const string&   ifname,
    const uint32_t& mtu,
    FeaIfmgrMirror01InterfaceSetMtuCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_mac(
    // Input values,
    const string&   ifname,
    const Mac&  mac) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetMacRF;

    class FeaIfmgrMirror01InterfaceSetMacCB {
        FeaIfmgrMirror01InterfaceSetMacRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetMacRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetMacRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetMacCB(const FeaIfmgrMirror01InterfaceSetMacRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetMacRsp :
      public FeaIfmgrMirror01InterfaceSetMacCB {
        FeaIfmgrMirror01InterfaceSetMacRsp(const FeaIfmgrMirror01InterfaceSetMacRF& cb)
          : FeaIfmgrMirror01InterfaceSetMacCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_mac
       (
    const string&   ifname,
    const Mac&  mac,
    FeaIfmgrMirror01InterfaceSetMacCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_pif_index(
    // Input values,
    const string&   ifname,
    const uint32_t& pif_index) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetPifIndexRF;

    class FeaIfmgrMirror01InterfaceSetPifIndexCB {
        FeaIfmgrMirror01InterfaceSetPifIndexRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetPifIndexRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetPifIndexRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetPifIndexCB(const FeaIfmgrMirror01InterfaceSetPifIndexRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetPifIndexRsp :
      public FeaIfmgrMirror01InterfaceSetPifIndexCB {
        FeaIfmgrMirror01InterfaceSetPifIndexRsp(const FeaIfmgrMirror01InterfaceSetPifIndexRF& cb)
          : FeaIfmgrMirror01InterfaceSetPifIndexCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_pif_index
       (
    const string&   ifname,
    const uint32_t& pif_index,
    FeaIfmgrMirror01InterfaceSetPifIndexCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_no_carrier(
    // Input values,
    const string&   ifname,
    const bool& no_carrier) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetNoCarrierRF;

    class FeaIfmgrMirror01InterfaceSetNoCarrierCB {
        FeaIfmgrMirror01InterfaceSetNoCarrierRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetNoCarrierRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetNoCarrierRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetNoCarrierCB(const FeaIfmgrMirror01InterfaceSetNoCarrierRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetNoCarrierRsp :
      public FeaIfmgrMirror01InterfaceSetNoCarrierCB {
        FeaIfmgrMirror01InterfaceSetNoCarrierRsp(const FeaIfmgrMirror01InterfaceSetNoCarrierRF& cb)
          : FeaIfmgrMirror01InterfaceSetNoCarrierCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_no_carrier
       (
    const string&   ifname,
    const bool& no_carrier,
    FeaIfmgrMirror01InterfaceSetNoCarrierCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_baudrate(
    // Input values,
    const string&   ifname,
    const uint64_t& baudrate) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetBaudrateRF;

    class FeaIfmgrMirror01InterfaceSetBaudrateCB {
        FeaIfmgrMirror01InterfaceSetBaudrateRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetBaudrateRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetBaudrateRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetBaudrateCB(const FeaIfmgrMirror01InterfaceSetBaudrateRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetBaudrateRsp :
      public FeaIfmgrMirror01InterfaceSetBaudrateCB {
        FeaIfmgrMirror01InterfaceSetBaudrateRsp(const FeaIfmgrMirror01InterfaceSetBaudrateRF& cb)
          : FeaIfmgrMirror01InterfaceSetBaudrateCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_baudrate
       (
    const string&   ifname,
    const uint64_t& baudrate,
    FeaIfmgrMirror01InterfaceSetBaudrateCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_parent_ifname(
    // Input values,
    const string&   ifname,
    const string&   parent_ifname) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetParentIfnameRF;

    class FeaIfmgrMirror01InterfaceSetParentIfnameCB {
        FeaIfmgrMirror01InterfaceSetParentIfnameRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetParentIfnameRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetParentIfnameRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetParentIfnameCB(const FeaIfmgrMirror01InterfaceSetParentIfnameRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetParentIfnameRsp :
      public FeaIfmgrMirror01InterfaceSetParentIfnameCB {
        FeaIfmgrMirror01InterfaceSetParentIfnameRsp(const FeaIfmgrMirror01InterfaceSetParentIfnameRF& cb)
          : FeaIfmgrMirror01InterfaceSetParentIfnameCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_parent_ifname
       (
    const string&   ifname,
    const string&   parent_ifname,
    FeaIfmgrMirror01InterfaceSetParentIfnameCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_iface_type(
    // Input values,
    const string&   ifname,
    const string&   iface_type) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetIfaceTypeRF;

    class FeaIfmgrMirror01InterfaceSetIfaceTypeCB {
        FeaIfmgrMirror01InterfaceSetIfaceTypeRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetIfaceTypeRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetIfaceTypeRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetIfaceTypeCB(const FeaIfmgrMirror01InterfaceSetIfaceTypeRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetIfaceTypeRsp :
      public FeaIfmgrMirror01InterfaceSetIfaceTypeCB {
        FeaIfmgrMirror01InterfaceSetIfaceTypeRsp(const FeaIfmgrMirror01InterfaceSetIfaceTypeRF& cb)
          : FeaIfmgrMirror01InterfaceSetIfaceTypeCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_iface_type
       (
    const string&   ifname,
    const string&   iface_type,
    FeaIfmgrMirror01InterfaceSetIfaceTypeCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_interface_set_vid(
    // Input values,
    const string&   ifname,
    const string&   vid) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01InterfaceSetVidRF;

    class FeaIfmgrMirror01InterfaceSetVidCB {
        FeaIfmgrMirror01InterfaceSetVidRF cb;

    public:
        operator const FeaIfmgrMirror01InterfaceSetVidRF& () const { return cb; }
        const FeaIfmgrMirror01InterfaceSetVidRF& operator ->() const { return cb; }
        FeaIfmgrMirror01InterfaceSetVidCB(const FeaIfmgrMirror01InterfaceSetVidRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01InterfaceSetVidRsp :
      public FeaIfmgrMirror01InterfaceSetVidCB {
        FeaIfmgrMirror01InterfaceSetVidRsp(const FeaIfmgrMirror01InterfaceSetVidRF& cb)
          : FeaIfmgrMirror01InterfaceSetVidCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_interface_set_vid
       (
    const string&   ifname,
    const string&   vid,
    FeaIfmgrMirror01InterfaceSetVidCB);
#endif

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

    class FeaIfmgrMirror01VifAddCB {
        FeaIfmgrMirror01VifAddRF cb;

    public:
        operator const FeaIfmgrMirror01VifAddRF& () const { return cb; }
        const FeaIfmgrMirror01VifAddRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifAddCB(const FeaIfmgrMirror01VifAddRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifAddRsp :
      public FeaIfmgrMirror01VifAddCB {
        FeaIfmgrMirror01VifAddRsp(const FeaIfmgrMirror01VifAddRF& cb)
          : FeaIfmgrMirror01VifAddCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_add
       (
    const string&   ifname,
    const string&   vifname,
    FeaIfmgrMirror01VifAddCB);
#endif

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

    class FeaIfmgrMirror01VifRemoveCB {
        FeaIfmgrMirror01VifRemoveRF cb;

    public:
        operator const FeaIfmgrMirror01VifRemoveRF& () const { return cb; }
        const FeaIfmgrMirror01VifRemoveRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifRemoveCB(const FeaIfmgrMirror01VifRemoveRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifRemoveRsp :
      public FeaIfmgrMirror01VifRemoveCB {
        FeaIfmgrMirror01VifRemoveRsp(const FeaIfmgrMirror01VifRemoveRF& cb)
          : FeaIfmgrMirror01VifRemoveCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_remove
       (
    const string&   ifname,
    const string&   vifname,
    FeaIfmgrMirror01VifRemoveCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_enabled(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& enabled) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetEnabledRF;

    class FeaIfmgrMirror01VifSetEnabledCB {
        FeaIfmgrMirror01VifSetEnabledRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetEnabledRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetEnabledRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetEnabledCB(const FeaIfmgrMirror01VifSetEnabledRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetEnabledRsp :
      public FeaIfmgrMirror01VifSetEnabledCB {
        FeaIfmgrMirror01VifSetEnabledRsp(const FeaIfmgrMirror01VifSetEnabledRF& cb)
          : FeaIfmgrMirror01VifSetEnabledCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_enabled
       (
    const string&   ifname,
    const string&   vifname,
    const bool& enabled,
    FeaIfmgrMirror01VifSetEnabledCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_multicast_capable(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& capable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetMulticastCapableRF;

    class FeaIfmgrMirror01VifSetMulticastCapableCB {
        FeaIfmgrMirror01VifSetMulticastCapableRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetMulticastCapableRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetMulticastCapableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetMulticastCapableCB(const FeaIfmgrMirror01VifSetMulticastCapableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetMulticastCapableRsp :
      public FeaIfmgrMirror01VifSetMulticastCapableCB {
        FeaIfmgrMirror01VifSetMulticastCapableRsp(const FeaIfmgrMirror01VifSetMulticastCapableRF& cb)
          : FeaIfmgrMirror01VifSetMulticastCapableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_multicast_capable
       (
    const string&   ifname,
    const string&   vifname,
    const bool& capable,
    FeaIfmgrMirror01VifSetMulticastCapableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_broadcast_capable(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& capable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetBroadcastCapableRF;

    class FeaIfmgrMirror01VifSetBroadcastCapableCB {
        FeaIfmgrMirror01VifSetBroadcastCapableRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetBroadcastCapableRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetBroadcastCapableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetBroadcastCapableCB(const FeaIfmgrMirror01VifSetBroadcastCapableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetBroadcastCapableRsp :
      public FeaIfmgrMirror01VifSetBroadcastCapableCB {
        FeaIfmgrMirror01VifSetBroadcastCapableRsp(const FeaIfmgrMirror01VifSetBroadcastCapableRF& cb)
          : FeaIfmgrMirror01VifSetBroadcastCapableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_broadcast_capable
       (
    const string&   ifname,
    const string&   vifname,
    const bool& capable,
    FeaIfmgrMirror01VifSetBroadcastCapableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_p2p_capable(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& capable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetP2PCapableRF;

    class FeaIfmgrMirror01VifSetP2PCapableCB {
        FeaIfmgrMirror01VifSetP2PCapableRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetP2PCapableRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetP2PCapableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetP2PCapableCB(const FeaIfmgrMirror01VifSetP2PCapableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetP2PCapableRsp :
      public FeaIfmgrMirror01VifSetP2PCapableCB {
        FeaIfmgrMirror01VifSetP2PCapableRsp(const FeaIfmgrMirror01VifSetP2PCapableRF& cb)
          : FeaIfmgrMirror01VifSetP2PCapableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_p2p_capable
       (
    const string&   ifname,
    const string&   vifname,
    const bool& capable,
    FeaIfmgrMirror01VifSetP2PCapableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_loopback(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& loopback) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetLoopbackRF;

    class FeaIfmgrMirror01VifSetLoopbackCB {
        FeaIfmgrMirror01VifSetLoopbackRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetLoopbackRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetLoopbackRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetLoopbackCB(const FeaIfmgrMirror01VifSetLoopbackRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetLoopbackRsp :
      public FeaIfmgrMirror01VifSetLoopbackCB {
        FeaIfmgrMirror01VifSetLoopbackRsp(const FeaIfmgrMirror01VifSetLoopbackRF& cb)
          : FeaIfmgrMirror01VifSetLoopbackCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_loopback
       (
    const string&   ifname,
    const string&   vifname,
    const bool& loopback,
    FeaIfmgrMirror01VifSetLoopbackCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_pim_register(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const bool& pim_register) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetPimRegisterRF;

    class FeaIfmgrMirror01VifSetPimRegisterCB {
        FeaIfmgrMirror01VifSetPimRegisterRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetPimRegisterRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetPimRegisterRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetPimRegisterCB(const FeaIfmgrMirror01VifSetPimRegisterRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetPimRegisterRsp :
      public FeaIfmgrMirror01VifSetPimRegisterCB {
        FeaIfmgrMirror01VifSetPimRegisterRsp(const FeaIfmgrMirror01VifSetPimRegisterRF& cb)
          : FeaIfmgrMirror01VifSetPimRegisterCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_pim_register
       (
    const string&   ifname,
    const string&   vifname,
    const bool& pim_register,
    FeaIfmgrMirror01VifSetPimRegisterCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_pif_index(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& pif_index) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetPifIndexRF;

    class FeaIfmgrMirror01VifSetPifIndexCB {
        FeaIfmgrMirror01VifSetPifIndexRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetPifIndexRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetPifIndexRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetPifIndexCB(const FeaIfmgrMirror01VifSetPifIndexRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetPifIndexRsp :
      public FeaIfmgrMirror01VifSetPifIndexCB {
        FeaIfmgrMirror01VifSetPifIndexRsp(const FeaIfmgrMirror01VifSetPifIndexRF& cb)
          : FeaIfmgrMirror01VifSetPifIndexCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_pif_index
       (
    const string&   ifname,
    const string&   vifname,
    const uint32_t& pif_index,
    FeaIfmgrMirror01VifSetPifIndexCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_vif_set_vif_index(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const uint32_t& vif_index) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01VifSetVifIndexRF;

    class FeaIfmgrMirror01VifSetVifIndexCB {
        FeaIfmgrMirror01VifSetVifIndexRF cb;

    public:
        operator const FeaIfmgrMirror01VifSetVifIndexRF& () const { return cb; }
        const FeaIfmgrMirror01VifSetVifIndexRF& operator ->() const { return cb; }
        FeaIfmgrMirror01VifSetVifIndexCB(const FeaIfmgrMirror01VifSetVifIndexRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01VifSetVifIndexRsp :
      public FeaIfmgrMirror01VifSetVifIndexCB {
        FeaIfmgrMirror01VifSetVifIndexRsp(const FeaIfmgrMirror01VifSetVifIndexRF& cb)
          : FeaIfmgrMirror01VifSetVifIndexCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_vif_set_vif_index
       (
    const string&   ifname,
    const string&   vifname,
    const uint32_t& vif_index,
    FeaIfmgrMirror01VifSetVifIndexCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_add(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4AddRF;

    class FeaIfmgrMirror01Ipv4AddCB {
        FeaIfmgrMirror01Ipv4AddRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4AddRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4AddRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4AddCB(const FeaIfmgrMirror01Ipv4AddRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4AddRsp :
      public FeaIfmgrMirror01Ipv4AddCB {
        FeaIfmgrMirror01Ipv4AddRsp(const FeaIfmgrMirror01Ipv4AddRF& cb)
          : FeaIfmgrMirror01Ipv4AddCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_add
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    FeaIfmgrMirror01Ipv4AddCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_remove(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4RemoveRF;

    class FeaIfmgrMirror01Ipv4RemoveCB {
        FeaIfmgrMirror01Ipv4RemoveRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4RemoveRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4RemoveRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4RemoveCB(const FeaIfmgrMirror01Ipv4RemoveRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4RemoveRsp :
      public FeaIfmgrMirror01Ipv4RemoveCB {
        FeaIfmgrMirror01Ipv4RemoveRsp(const FeaIfmgrMirror01Ipv4RemoveRF& cb)
          : FeaIfmgrMirror01Ipv4RemoveCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_remove
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    FeaIfmgrMirror01Ipv4RemoveCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_prefix(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const uint32_t& prefix_len) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetPrefixRF;

    class FeaIfmgrMirror01Ipv4SetPrefixCB {
        FeaIfmgrMirror01Ipv4SetPrefixRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetPrefixRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetPrefixRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetPrefixCB(const FeaIfmgrMirror01Ipv4SetPrefixRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetPrefixRsp :
      public FeaIfmgrMirror01Ipv4SetPrefixCB {
        FeaIfmgrMirror01Ipv4SetPrefixRsp(const FeaIfmgrMirror01Ipv4SetPrefixRF& cb)
          : FeaIfmgrMirror01Ipv4SetPrefixCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_prefix
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const uint32_t& prefix_len,
    FeaIfmgrMirror01Ipv4SetPrefixCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_enabled(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& enabled) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetEnabledRF;

    class FeaIfmgrMirror01Ipv4SetEnabledCB {
        FeaIfmgrMirror01Ipv4SetEnabledRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetEnabledRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetEnabledRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetEnabledCB(const FeaIfmgrMirror01Ipv4SetEnabledRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetEnabledRsp :
      public FeaIfmgrMirror01Ipv4SetEnabledCB {
        FeaIfmgrMirror01Ipv4SetEnabledRsp(const FeaIfmgrMirror01Ipv4SetEnabledRF& cb)
          : FeaIfmgrMirror01Ipv4SetEnabledCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_enabled
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& enabled,
    FeaIfmgrMirror01Ipv4SetEnabledCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_multicast_capable(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& capable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetMulticastCapableRF;

    class FeaIfmgrMirror01Ipv4SetMulticastCapableCB {
        FeaIfmgrMirror01Ipv4SetMulticastCapableRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetMulticastCapableRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetMulticastCapableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetMulticastCapableCB(const FeaIfmgrMirror01Ipv4SetMulticastCapableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetMulticastCapableRsp :
      public FeaIfmgrMirror01Ipv4SetMulticastCapableCB {
        FeaIfmgrMirror01Ipv4SetMulticastCapableRsp(const FeaIfmgrMirror01Ipv4SetMulticastCapableRF& cb)
          : FeaIfmgrMirror01Ipv4SetMulticastCapableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_multicast_capable
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& capable,
    FeaIfmgrMirror01Ipv4SetMulticastCapableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_loopback(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& loopback) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetLoopbackRF;

    class FeaIfmgrMirror01Ipv4SetLoopbackCB {
        FeaIfmgrMirror01Ipv4SetLoopbackRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetLoopbackRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetLoopbackRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetLoopbackCB(const FeaIfmgrMirror01Ipv4SetLoopbackRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetLoopbackRsp :
      public FeaIfmgrMirror01Ipv4SetLoopbackCB {
        FeaIfmgrMirror01Ipv4SetLoopbackRsp(const FeaIfmgrMirror01Ipv4SetLoopbackRF& cb)
          : FeaIfmgrMirror01Ipv4SetLoopbackCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_loopback
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const bool& loopback,
    FeaIfmgrMirror01Ipv4SetLoopbackCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_broadcast(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const IPv4& broadcast_addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetBroadcastRF;

    class FeaIfmgrMirror01Ipv4SetBroadcastCB {
        FeaIfmgrMirror01Ipv4SetBroadcastRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetBroadcastRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetBroadcastRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetBroadcastCB(const FeaIfmgrMirror01Ipv4SetBroadcastRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetBroadcastRsp :
      public FeaIfmgrMirror01Ipv4SetBroadcastCB {
        FeaIfmgrMirror01Ipv4SetBroadcastRsp(const FeaIfmgrMirror01Ipv4SetBroadcastRF& cb)
          : FeaIfmgrMirror01Ipv4SetBroadcastCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_broadcast
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const IPv4& broadcast_addr,
    FeaIfmgrMirror01Ipv4SetBroadcastCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv4_set_endpoint(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const IPv4& endpoint_addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv4SetEndpointRF;

    class FeaIfmgrMirror01Ipv4SetEndpointCB {
        FeaIfmgrMirror01Ipv4SetEndpointRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv4SetEndpointRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv4SetEndpointRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv4SetEndpointCB(const FeaIfmgrMirror01Ipv4SetEndpointRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv4SetEndpointRsp :
      public FeaIfmgrMirror01Ipv4SetEndpointCB {
        FeaIfmgrMirror01Ipv4SetEndpointRsp(const FeaIfmgrMirror01Ipv4SetEndpointRF& cb)
          : FeaIfmgrMirror01Ipv4SetEndpointCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv4_set_endpoint
       (
    const string&   ifname,
    const string&   vifname,
    const IPv4& addr,
    const IPv4& endpoint_addr,
    FeaIfmgrMirror01Ipv4SetEndpointCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_add(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6AddRF;

    class FeaIfmgrMirror01Ipv6AddCB {
        FeaIfmgrMirror01Ipv6AddRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6AddRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6AddRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6AddCB(const FeaIfmgrMirror01Ipv6AddRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6AddRsp :
      public FeaIfmgrMirror01Ipv6AddCB {
        FeaIfmgrMirror01Ipv6AddRsp(const FeaIfmgrMirror01Ipv6AddRF& cb)
          : FeaIfmgrMirror01Ipv6AddCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_add
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    FeaIfmgrMirror01Ipv6AddCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_remove(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6RemoveRF;

    class FeaIfmgrMirror01Ipv6RemoveCB {
        FeaIfmgrMirror01Ipv6RemoveRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6RemoveRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6RemoveRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6RemoveCB(const FeaIfmgrMirror01Ipv6RemoveRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6RemoveRsp :
      public FeaIfmgrMirror01Ipv6RemoveCB {
        FeaIfmgrMirror01Ipv6RemoveRsp(const FeaIfmgrMirror01Ipv6RemoveRF& cb)
          : FeaIfmgrMirror01Ipv6RemoveCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_remove
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    FeaIfmgrMirror01Ipv6RemoveCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_set_prefix(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const uint32_t& prefix_len) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6SetPrefixRF;

    class FeaIfmgrMirror01Ipv6SetPrefixCB {
        FeaIfmgrMirror01Ipv6SetPrefixRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6SetPrefixRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6SetPrefixRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6SetPrefixCB(const FeaIfmgrMirror01Ipv6SetPrefixRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6SetPrefixRsp :
      public FeaIfmgrMirror01Ipv6SetPrefixCB {
        FeaIfmgrMirror01Ipv6SetPrefixRsp(const FeaIfmgrMirror01Ipv6SetPrefixRF& cb)
          : FeaIfmgrMirror01Ipv6SetPrefixCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_set_prefix
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const uint32_t& prefix_len,
    FeaIfmgrMirror01Ipv6SetPrefixCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_set_enabled(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& enabled) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6SetEnabledRF;

    class FeaIfmgrMirror01Ipv6SetEnabledCB {
        FeaIfmgrMirror01Ipv6SetEnabledRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6SetEnabledRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6SetEnabledRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6SetEnabledCB(const FeaIfmgrMirror01Ipv6SetEnabledRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6SetEnabledRsp :
      public FeaIfmgrMirror01Ipv6SetEnabledCB {
        FeaIfmgrMirror01Ipv6SetEnabledRsp(const FeaIfmgrMirror01Ipv6SetEnabledRF& cb)
          : FeaIfmgrMirror01Ipv6SetEnabledCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_set_enabled
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& enabled,
    FeaIfmgrMirror01Ipv6SetEnabledCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_set_loopback(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& loopback) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6SetLoopbackRF;

    class FeaIfmgrMirror01Ipv6SetLoopbackCB {
        FeaIfmgrMirror01Ipv6SetLoopbackRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6SetLoopbackRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6SetLoopbackRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6SetLoopbackCB(const FeaIfmgrMirror01Ipv6SetLoopbackRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6SetLoopbackRsp :
      public FeaIfmgrMirror01Ipv6SetLoopbackCB {
        FeaIfmgrMirror01Ipv6SetLoopbackRsp(const FeaIfmgrMirror01Ipv6SetLoopbackRF& cb)
          : FeaIfmgrMirror01Ipv6SetLoopbackCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_set_loopback
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& loopback,
    FeaIfmgrMirror01Ipv6SetLoopbackCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_set_multicast_capable(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& capable) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6SetMulticastCapableRF;

    class FeaIfmgrMirror01Ipv6SetMulticastCapableCB {
        FeaIfmgrMirror01Ipv6SetMulticastCapableRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6SetMulticastCapableRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6SetMulticastCapableRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6SetMulticastCapableCB(const FeaIfmgrMirror01Ipv6SetMulticastCapableRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6SetMulticastCapableRsp :
      public FeaIfmgrMirror01Ipv6SetMulticastCapableCB {
        FeaIfmgrMirror01Ipv6SetMulticastCapableRsp(const FeaIfmgrMirror01Ipv6SetMulticastCapableRF& cb)
          : FeaIfmgrMirror01Ipv6SetMulticastCapableCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_set_multicast_capable
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const bool& capable,
    FeaIfmgrMirror01Ipv6SetMulticastCapableCB);
#endif

    virtual XrlCmdError fea_ifmgr_mirror_0_1_ipv6_set_endpoint(
    // Input values,
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const IPv6& endpoint_addr) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    FeaIfmgrMirror01Ipv6SetEndpointRF;

    class FeaIfmgrMirror01Ipv6SetEndpointCB {
        FeaIfmgrMirror01Ipv6SetEndpointRF cb;

    public:
        operator const FeaIfmgrMirror01Ipv6SetEndpointRF& () const { return cb; }
        const FeaIfmgrMirror01Ipv6SetEndpointRF& operator ->() const { return cb; }
        FeaIfmgrMirror01Ipv6SetEndpointCB(const FeaIfmgrMirror01Ipv6SetEndpointRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01Ipv6SetEndpointRsp :
      public FeaIfmgrMirror01Ipv6SetEndpointCB {
        FeaIfmgrMirror01Ipv6SetEndpointRsp(const FeaIfmgrMirror01Ipv6SetEndpointRF& cb)
          : FeaIfmgrMirror01Ipv6SetEndpointCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_ipv6_set_endpoint
       (
    const string&   ifname,
    const string&   vifname,
    const IPv6& addr,
    const IPv6& endpoint_addr,
    FeaIfmgrMirror01Ipv6SetEndpointCB);
#endif

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

    class FeaIfmgrMirror01HintTreeCompleteCB {
        FeaIfmgrMirror01HintTreeCompleteRF cb;

    public:
        operator const FeaIfmgrMirror01HintTreeCompleteRF& () const { return cb; }
        const FeaIfmgrMirror01HintTreeCompleteRF& operator ->() const { return cb; }
        FeaIfmgrMirror01HintTreeCompleteCB(const FeaIfmgrMirror01HintTreeCompleteRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01HintTreeCompleteRsp :
      public FeaIfmgrMirror01HintTreeCompleteCB {
        FeaIfmgrMirror01HintTreeCompleteRsp(const FeaIfmgrMirror01HintTreeCompleteRF& cb)
          : FeaIfmgrMirror01HintTreeCompleteCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_hint_tree_complete
       (
    FeaIfmgrMirror01HintTreeCompleteCB);
#endif

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

    class FeaIfmgrMirror01HintUpdatesMadeCB {
        FeaIfmgrMirror01HintUpdatesMadeRF cb;

    public:
        operator const FeaIfmgrMirror01HintUpdatesMadeRF& () const { return cb; }
        const FeaIfmgrMirror01HintUpdatesMadeRF& operator ->() const { return cb; }
        FeaIfmgrMirror01HintUpdatesMadeCB(const FeaIfmgrMirror01HintUpdatesMadeRF& cb)
          : cb(cb) { }

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

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

    struct FeaIfmgrMirror01HintUpdatesMadeRsp :
      public FeaIfmgrMirror01HintUpdatesMadeCB {
        FeaIfmgrMirror01HintUpdatesMadeRsp(const FeaIfmgrMirror01HintUpdatesMadeRF& cb)
          : FeaIfmgrMirror01HintUpdatesMadeCB(cb) { }

    };

    virtual void async_fea_ifmgr_mirror_0_1_hint_updates_made
       (
    FeaIfmgrMirror01HintUpdatesMadeCB);
#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_fea_ifmgr_mirror_0_1_interface_add(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_fea_ifmgr_mirror_0_1_interface_add
       (const XrlCmdError &e,
        XrlRespCallback);
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void add_handlers();
    void remove_handlers();

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

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

#endif // __XRL_TARGETS_FEA_IFMGR_MIRROR_BASE_HH__