mfea_base.hh

/*
 * obj/i386-pc-mingw32/xrl/targets/mfea_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_MFEA_BASE_HH__
#define __XRL_TARGETS_MFEA_BASE_HH__

#undef XORP_LIBRARY_NAME
#define XORP_LIBRARY_NAME "XrlMfeaTarget"

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

class XrlMfeaTargetBase {
protected:
    XrlCmdMap* _cmds;

public:
    XrlMfeaTargetBase(XrlCmdMap* cmds = 0);

    virtual ~XrlMfeaTargetBase();

    bool set_command_map(XrlCmdMap* cmds);

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

    const char* version() const { return "mfea/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 cli_processor_0_1_process_command(
    // Input values,
    const string&   processor_name,
    const string&   cli_term_name,
    const uint32_t& cli_session_id,
    const string&   command_name,
    const string&   command_args,
    // Output values,
    string& ret_processor_name,
    string& ret_cli_term_name,
    uint32_t&   ret_cli_session_id,
    string& ret_command_output) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback5<void, const XrlCmdError &,
    const string*,
    const string*,
    const uint32_t*,
    const string*>::RefPtr
    CliProcessor01ProcessCommandRF;

    class CliProcessor01ProcessCommandCB {
        CliProcessor01ProcessCommandRF cb;

    public:
        operator const CliProcessor01ProcessCommandRF& () const { return cb; }
        const CliProcessor01ProcessCommandRF& operator ->() const { return cb; }
        CliProcessor01ProcessCommandCB(const CliProcessor01ProcessCommandRF& cb)
          : cb(cb) { }

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

        void respond(const string& arg_ret_processor_name,
                     const string& arg_ret_cli_term_name,
                     const uint32_t& arg_ret_cli_session_id,
                     const string& arg_ret_command_output) const {
            cb->dispatch(XrlCmdError::OKAY(),
                         &arg_ret_processor_name,
                         &arg_ret_cli_term_name,
                         &arg_ret_cli_session_id,
                         &arg_ret_command_output);
        }
    };

    struct CliProcessor01ProcessCommandRsp :
      public CliProcessor01ProcessCommandCB {
        struct args_str {
            string ret_processor_name;
            string ret_cli_term_name;
            uint32_t ret_cli_session_id;
            string ret_command_output;
        };

    private:
        args_str args;

    public:
        CliProcessor01ProcessCommandRsp(const CliProcessor01ProcessCommandRF& cb)
          : CliProcessor01ProcessCommandCB(cb) { }

        void respond() const {
            CliProcessor01ProcessCommandCB::
            respond(args.ret_processor_name,
                        args.ret_cli_term_name,
                        args.ret_cli_session_id,
                        args.ret_command_output);
        }

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

    virtual void async_cli_processor_0_1_process_command
       (
    const string&   processor_name,
    const string&   cli_term_name,
    const uint32_t& cli_session_id,
    const string&   command_name,
    const string&   command_args,
    CliProcessor01ProcessCommandCB);
#endif

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

    class IfmgrReplicator01RegisterIfmgrMirrorCB {
        IfmgrReplicator01RegisterIfmgrMirrorRF cb;

    public:
        operator const IfmgrReplicator01RegisterIfmgrMirrorRF& () const { return cb; }
        const IfmgrReplicator01RegisterIfmgrMirrorRF& operator ->() const { return cb; }
        IfmgrReplicator01RegisterIfmgrMirrorCB(const IfmgrReplicator01RegisterIfmgrMirrorRF& cb)
          : cb(cb) { }

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

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

    struct IfmgrReplicator01RegisterIfmgrMirrorRsp :
      public IfmgrReplicator01RegisterIfmgrMirrorCB {
        IfmgrReplicator01RegisterIfmgrMirrorRsp(const IfmgrReplicator01RegisterIfmgrMirrorRF& cb)
          : IfmgrReplicator01RegisterIfmgrMirrorCB(cb) { }

    };

    virtual void async_ifmgr_replicator_0_1_register_ifmgr_mirror
       (
    const string&   clientname,
    IfmgrReplicator01RegisterIfmgrMirrorCB);
#endif

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

    class IfmgrReplicator01UnregisterIfmgrMirrorCB {
        IfmgrReplicator01UnregisterIfmgrMirrorRF cb;

    public:
        operator const IfmgrReplicator01UnregisterIfmgrMirrorRF& () const { return cb; }
        const IfmgrReplicator01UnregisterIfmgrMirrorRF& operator ->() const { return cb; }
        IfmgrReplicator01UnregisterIfmgrMirrorCB(const IfmgrReplicator01UnregisterIfmgrMirrorRF& cb)
          : cb(cb) { }

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

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

    struct IfmgrReplicator01UnregisterIfmgrMirrorRsp :
      public IfmgrReplicator01UnregisterIfmgrMirrorCB {
        IfmgrReplicator01UnregisterIfmgrMirrorRsp(const IfmgrReplicator01UnregisterIfmgrMirrorRF& cb)
          : IfmgrReplicator01UnregisterIfmgrMirrorCB(cb) { }

    };

    virtual void async_ifmgr_replicator_0_1_unregister_ifmgr_mirror
       (
    const string&   clientname,
    IfmgrReplicator01UnregisterIfmgrMirrorCB);
#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 mfea_0_1_have_multicast_routing4(
    // Output values,
    bool&   result) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback2<void, const XrlCmdError &,
    const bool*>::RefPtr
    Mfea01HaveMulticastRouting4RF;

    class Mfea01HaveMulticastRouting4CB {
        Mfea01HaveMulticastRouting4RF cb;

    public:
        operator const Mfea01HaveMulticastRouting4RF& () const { return cb; }
        const Mfea01HaveMulticastRouting4RF& operator ->() const { return cb; }
        Mfea01HaveMulticastRouting4CB(const Mfea01HaveMulticastRouting4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01HaveMulticastRouting4Rsp :
      public Mfea01HaveMulticastRouting4CB {
        struct args_str {
            bool result;
        };

    private:
        args_str args;

    public:
        Mfea01HaveMulticastRouting4Rsp(const Mfea01HaveMulticastRouting4RF& cb)
          : Mfea01HaveMulticastRouting4CB(cb) { }

        void respond() const {
            Mfea01HaveMulticastRouting4CB::
            respond(args.result);
        }

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

    virtual void async_mfea_0_1_have_multicast_routing4
       (
    Mfea01HaveMulticastRouting4CB);
#endif

    virtual XrlCmdError mfea_0_1_register_protocol4(
    // Input values,
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    const uint32_t& ip_protocol) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01RegisterProtocol4RF;

    class Mfea01RegisterProtocol4CB {
        Mfea01RegisterProtocol4RF cb;

    public:
        operator const Mfea01RegisterProtocol4RF& () const { return cb; }
        const Mfea01RegisterProtocol4RF& operator ->() const { return cb; }
        Mfea01RegisterProtocol4CB(const Mfea01RegisterProtocol4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01RegisterProtocol4Rsp :
      public Mfea01RegisterProtocol4CB {
        Mfea01RegisterProtocol4Rsp(const Mfea01RegisterProtocol4RF& cb)
          : Mfea01RegisterProtocol4CB(cb) { }

    };

    virtual void async_mfea_0_1_register_protocol4
       (
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    const uint32_t& ip_protocol,
    Mfea01RegisterProtocol4CB);
#endif

    virtual XrlCmdError mfea_0_1_unregister_protocol4(
    // Input values,
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01UnregisterProtocol4RF;

    class Mfea01UnregisterProtocol4CB {
        Mfea01UnregisterProtocol4RF cb;

    public:
        operator const Mfea01UnregisterProtocol4RF& () const { return cb; }
        const Mfea01UnregisterProtocol4RF& operator ->() const { return cb; }
        Mfea01UnregisterProtocol4CB(const Mfea01UnregisterProtocol4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01UnregisterProtocol4Rsp :
      public Mfea01UnregisterProtocol4CB {
        Mfea01UnregisterProtocol4Rsp(const Mfea01UnregisterProtocol4RF& cb)
          : Mfea01UnregisterProtocol4CB(cb) { }

    };

    virtual void async_mfea_0_1_unregister_protocol4
       (
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    Mfea01UnregisterProtocol4CB);
#endif

    virtual XrlCmdError mfea_0_1_add_mfc4(
    // Input values,
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& iif_vif_index,
    const vector<uint8_t>&  oiflist,
    const vector<uint8_t>&  oiflist_disable_wrongvif,
    const uint32_t& max_vifs_oiflist,
    const IPv4& rp_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01AddMfc4RF;

    class Mfea01AddMfc4CB {
        Mfea01AddMfc4RF cb;

    public:
        operator const Mfea01AddMfc4RF& () const { return cb; }
        const Mfea01AddMfc4RF& operator ->() const { return cb; }
        Mfea01AddMfc4CB(const Mfea01AddMfc4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01AddMfc4Rsp :
      public Mfea01AddMfc4CB {
        Mfea01AddMfc4Rsp(const Mfea01AddMfc4RF& cb)
          : Mfea01AddMfc4CB(cb) { }

    };

    virtual void async_mfea_0_1_add_mfc4
       (
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& iif_vif_index,
    const vector<uint8_t>&  oiflist,
    const vector<uint8_t>&  oiflist_disable_wrongvif,
    const uint32_t& max_vifs_oiflist,
    const IPv4& rp_address,
    Mfea01AddMfc4CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_mfc4(
    // Input values,
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteMfc4RF;

    class Mfea01DeleteMfc4CB {
        Mfea01DeleteMfc4RF cb;

    public:
        operator const Mfea01DeleteMfc4RF& () const { return cb; }
        const Mfea01DeleteMfc4RF& operator ->() const { return cb; }
        Mfea01DeleteMfc4CB(const Mfea01DeleteMfc4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteMfc4Rsp :
      public Mfea01DeleteMfc4CB {
        Mfea01DeleteMfc4Rsp(const Mfea01DeleteMfc4RF& cb)
          : Mfea01DeleteMfc4CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_mfc4
       (
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    Mfea01DeleteMfc4CB);
#endif

    virtual XrlCmdError mfea_0_1_add_dataflow_monitor4(
    // Input values,
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01AddDataflowMonitor4RF;

    class Mfea01AddDataflowMonitor4CB {
        Mfea01AddDataflowMonitor4RF cb;

    public:
        operator const Mfea01AddDataflowMonitor4RF& () const { return cb; }
        const Mfea01AddDataflowMonitor4RF& operator ->() const { return cb; }
        Mfea01AddDataflowMonitor4CB(const Mfea01AddDataflowMonitor4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01AddDataflowMonitor4Rsp :
      public Mfea01AddDataflowMonitor4CB {
        Mfea01AddDataflowMonitor4Rsp(const Mfea01AddDataflowMonitor4RF& cb)
          : Mfea01AddDataflowMonitor4CB(cb) { }

    };

    virtual void async_mfea_0_1_add_dataflow_monitor4
       (
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall,
    Mfea01AddDataflowMonitor4CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_dataflow_monitor4(
    // Input values,
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteDataflowMonitor4RF;

    class Mfea01DeleteDataflowMonitor4CB {
        Mfea01DeleteDataflowMonitor4RF cb;

    public:
        operator const Mfea01DeleteDataflowMonitor4RF& () const { return cb; }
        const Mfea01DeleteDataflowMonitor4RF& operator ->() const { return cb; }
        Mfea01DeleteDataflowMonitor4CB(const Mfea01DeleteDataflowMonitor4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteDataflowMonitor4Rsp :
      public Mfea01DeleteDataflowMonitor4CB {
        Mfea01DeleteDataflowMonitor4Rsp(const Mfea01DeleteDataflowMonitor4RF& cb)
          : Mfea01DeleteDataflowMonitor4CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_dataflow_monitor4
       (
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall,
    Mfea01DeleteDataflowMonitor4CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_all_dataflow_monitor4(
    // Input values,
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteAllDataflowMonitor4RF;

    class Mfea01DeleteAllDataflowMonitor4CB {
        Mfea01DeleteAllDataflowMonitor4RF cb;

    public:
        operator const Mfea01DeleteAllDataflowMonitor4RF& () const { return cb; }
        const Mfea01DeleteAllDataflowMonitor4RF& operator ->() const { return cb; }
        Mfea01DeleteAllDataflowMonitor4CB(const Mfea01DeleteAllDataflowMonitor4RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteAllDataflowMonitor4Rsp :
      public Mfea01DeleteAllDataflowMonitor4CB {
        Mfea01DeleteAllDataflowMonitor4Rsp(const Mfea01DeleteAllDataflowMonitor4RF& cb)
          : Mfea01DeleteAllDataflowMonitor4CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_all_dataflow_monitor4
       (
    const string&   xrl_sender_name,
    const IPv4& source_address,
    const IPv4& group_address,
    Mfea01DeleteAllDataflowMonitor4CB);
#endif

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

    class Mfea01EnableVifCB {
        Mfea01EnableVifRF cb;

    public:
        operator const Mfea01EnableVifRF& () const { return cb; }
        const Mfea01EnableVifRF& operator ->() const { return cb; }
        Mfea01EnableVifCB(const Mfea01EnableVifRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01EnableVifRsp :
      public Mfea01EnableVifCB {
        Mfea01EnableVifRsp(const Mfea01EnableVifRF& cb)
          : Mfea01EnableVifCB(cb) { }

    };

    virtual void async_mfea_0_1_enable_vif
       (
    const string&   vif_name,
    const bool& enable,
    Mfea01EnableVifCB);
#endif

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

    class Mfea01StartVifCB {
        Mfea01StartVifRF cb;

    public:
        operator const Mfea01StartVifRF& () const { return cb; }
        const Mfea01StartVifRF& operator ->() const { return cb; }
        Mfea01StartVifCB(const Mfea01StartVifRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StartVifRsp :
      public Mfea01StartVifCB {
        Mfea01StartVifRsp(const Mfea01StartVifRF& cb)
          : Mfea01StartVifCB(cb) { }

    };

    virtual void async_mfea_0_1_start_vif
       (
    const string&   vif_name,
    Mfea01StartVifCB);
#endif

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

    class Mfea01StopVifCB {
        Mfea01StopVifRF cb;

    public:
        operator const Mfea01StopVifRF& () const { return cb; }
        const Mfea01StopVifRF& operator ->() const { return cb; }
        Mfea01StopVifCB(const Mfea01StopVifRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StopVifRsp :
      public Mfea01StopVifCB {
        Mfea01StopVifRsp(const Mfea01StopVifRF& cb)
          : Mfea01StopVifCB(cb) { }

    };

    virtual void async_mfea_0_1_stop_vif
       (
    const string&   vif_name,
    Mfea01StopVifCB);
#endif

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

    class Mfea01EnableAllVifsCB {
        Mfea01EnableAllVifsRF cb;

    public:
        operator const Mfea01EnableAllVifsRF& () const { return cb; }
        const Mfea01EnableAllVifsRF& operator ->() const { return cb; }
        Mfea01EnableAllVifsCB(const Mfea01EnableAllVifsRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01EnableAllVifsRsp :
      public Mfea01EnableAllVifsCB {
        Mfea01EnableAllVifsRsp(const Mfea01EnableAllVifsRF& cb)
          : Mfea01EnableAllVifsCB(cb) { }

    };

    virtual void async_mfea_0_1_enable_all_vifs
       (
    const bool& enable,
    Mfea01EnableAllVifsCB);
#endif

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

    class Mfea01StartAllVifsCB {
        Mfea01StartAllVifsRF cb;

    public:
        operator const Mfea01StartAllVifsRF& () const { return cb; }
        const Mfea01StartAllVifsRF& operator ->() const { return cb; }
        Mfea01StartAllVifsCB(const Mfea01StartAllVifsRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StartAllVifsRsp :
      public Mfea01StartAllVifsCB {
        Mfea01StartAllVifsRsp(const Mfea01StartAllVifsRF& cb)
          : Mfea01StartAllVifsCB(cb) { }

    };

    virtual void async_mfea_0_1_start_all_vifs
       (
    Mfea01StartAllVifsCB);
#endif

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

    class Mfea01StopAllVifsCB {
        Mfea01StopAllVifsRF cb;

    public:
        operator const Mfea01StopAllVifsRF& () const { return cb; }
        const Mfea01StopAllVifsRF& operator ->() const { return cb; }
        Mfea01StopAllVifsCB(const Mfea01StopAllVifsRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StopAllVifsRsp :
      public Mfea01StopAllVifsCB {
        Mfea01StopAllVifsRsp(const Mfea01StopAllVifsRF& cb)
          : Mfea01StopAllVifsCB(cb) { }

    };

    virtual void async_mfea_0_1_stop_all_vifs
       (
    Mfea01StopAllVifsCB);
#endif

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

    class Mfea01EnableMfeaCB {
        Mfea01EnableMfeaRF cb;

    public:
        operator const Mfea01EnableMfeaRF& () const { return cb; }
        const Mfea01EnableMfeaRF& operator ->() const { return cb; }
        Mfea01EnableMfeaCB(const Mfea01EnableMfeaRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01EnableMfeaRsp :
      public Mfea01EnableMfeaCB {
        Mfea01EnableMfeaRsp(const Mfea01EnableMfeaRF& cb)
          : Mfea01EnableMfeaCB(cb) { }

    };

    virtual void async_mfea_0_1_enable_mfea
       (
    const bool& enable,
    Mfea01EnableMfeaCB);
#endif

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

    class Mfea01StartMfeaCB {
        Mfea01StartMfeaRF cb;

    public:
        operator const Mfea01StartMfeaRF& () const { return cb; }
        const Mfea01StartMfeaRF& operator ->() const { return cb; }
        Mfea01StartMfeaCB(const Mfea01StartMfeaRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StartMfeaRsp :
      public Mfea01StartMfeaCB {
        Mfea01StartMfeaRsp(const Mfea01StartMfeaRF& cb)
          : Mfea01StartMfeaCB(cb) { }

    };

    virtual void async_mfea_0_1_start_mfea
       (
    Mfea01StartMfeaCB);
#endif

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

    class Mfea01StopMfeaCB {
        Mfea01StopMfeaRF cb;

    public:
        operator const Mfea01StopMfeaRF& () const { return cb; }
        const Mfea01StopMfeaRF& operator ->() const { return cb; }
        Mfea01StopMfeaCB(const Mfea01StopMfeaRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StopMfeaRsp :
      public Mfea01StopMfeaCB {
        Mfea01StopMfeaRsp(const Mfea01StopMfeaRF& cb)
          : Mfea01StopMfeaCB(cb) { }

    };

    virtual void async_mfea_0_1_stop_mfea
       (
    Mfea01StopMfeaCB);
#endif

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

    class Mfea01EnableCliCB {
        Mfea01EnableCliRF cb;

    public:
        operator const Mfea01EnableCliRF& () const { return cb; }
        const Mfea01EnableCliRF& operator ->() const { return cb; }
        Mfea01EnableCliCB(const Mfea01EnableCliRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01EnableCliRsp :
      public Mfea01EnableCliCB {
        Mfea01EnableCliRsp(const Mfea01EnableCliRF& cb)
          : Mfea01EnableCliCB(cb) { }

    };

    virtual void async_mfea_0_1_enable_cli
       (
    const bool& enable,
    Mfea01EnableCliCB);
#endif

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

    class Mfea01StartCliCB {
        Mfea01StartCliRF cb;

    public:
        operator const Mfea01StartCliRF& () const { return cb; }
        const Mfea01StartCliRF& operator ->() const { return cb; }
        Mfea01StartCliCB(const Mfea01StartCliRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StartCliRsp :
      public Mfea01StartCliCB {
        Mfea01StartCliRsp(const Mfea01StartCliRF& cb)
          : Mfea01StartCliCB(cb) { }

    };

    virtual void async_mfea_0_1_start_cli
       (
    Mfea01StartCliCB);
#endif

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

    class Mfea01StopCliCB {
        Mfea01StopCliRF cb;

    public:
        operator const Mfea01StopCliRF& () const { return cb; }
        const Mfea01StopCliRF& operator ->() const { return cb; }
        Mfea01StopCliCB(const Mfea01StopCliRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01StopCliRsp :
      public Mfea01StopCliCB {
        Mfea01StopCliRsp(const Mfea01StopCliRF& cb)
          : Mfea01StopCliCB(cb) { }

    };

    virtual void async_mfea_0_1_stop_cli
       (
    Mfea01StopCliCB);
#endif

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

    class Mfea01LogTraceAllCB {
        Mfea01LogTraceAllRF cb;

    public:
        operator const Mfea01LogTraceAllRF& () const { return cb; }
        const Mfea01LogTraceAllRF& operator ->() const { return cb; }
        Mfea01LogTraceAllCB(const Mfea01LogTraceAllRF& cb)
          : cb(cb) { }

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

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

    struct Mfea01LogTraceAllRsp :
      public Mfea01LogTraceAllCB {
        Mfea01LogTraceAllRsp(const Mfea01LogTraceAllRF& cb)
          : Mfea01LogTraceAllCB(cb) { }

    };

    virtual void async_mfea_0_1_log_trace_all
       (
    const bool& enable,
    Mfea01LogTraceAllCB);
#endif

    virtual XrlCmdError mfea_0_1_have_multicast_routing6(
    // Output values,
    bool&   result) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback2<void, const XrlCmdError &,
    const bool*>::RefPtr
    Mfea01HaveMulticastRouting6RF;

    class Mfea01HaveMulticastRouting6CB {
        Mfea01HaveMulticastRouting6RF cb;

    public:
        operator const Mfea01HaveMulticastRouting6RF& () const { return cb; }
        const Mfea01HaveMulticastRouting6RF& operator ->() const { return cb; }
        Mfea01HaveMulticastRouting6CB(const Mfea01HaveMulticastRouting6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01HaveMulticastRouting6Rsp :
      public Mfea01HaveMulticastRouting6CB {
        struct args_str {
            bool result;
        };

    private:
        args_str args;

    public:
        Mfea01HaveMulticastRouting6Rsp(const Mfea01HaveMulticastRouting6RF& cb)
          : Mfea01HaveMulticastRouting6CB(cb) { }

        void respond() const {
            Mfea01HaveMulticastRouting6CB::
            respond(args.result);
        }

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

    virtual void async_mfea_0_1_have_multicast_routing6
       (
    Mfea01HaveMulticastRouting6CB);
#endif

    virtual XrlCmdError mfea_0_1_register_protocol6(
    // Input values,
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    const uint32_t& ip_protocol) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01RegisterProtocol6RF;

    class Mfea01RegisterProtocol6CB {
        Mfea01RegisterProtocol6RF cb;

    public:
        operator const Mfea01RegisterProtocol6RF& () const { return cb; }
        const Mfea01RegisterProtocol6RF& operator ->() const { return cb; }
        Mfea01RegisterProtocol6CB(const Mfea01RegisterProtocol6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01RegisterProtocol6Rsp :
      public Mfea01RegisterProtocol6CB {
        Mfea01RegisterProtocol6Rsp(const Mfea01RegisterProtocol6RF& cb)
          : Mfea01RegisterProtocol6CB(cb) { }

    };

    virtual void async_mfea_0_1_register_protocol6
       (
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    const uint32_t& ip_protocol,
    Mfea01RegisterProtocol6CB);
#endif

    virtual XrlCmdError mfea_0_1_unregister_protocol6(
    // Input values,
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01UnregisterProtocol6RF;

    class Mfea01UnregisterProtocol6CB {
        Mfea01UnregisterProtocol6RF cb;

    public:
        operator const Mfea01UnregisterProtocol6RF& () const { return cb; }
        const Mfea01UnregisterProtocol6RF& operator ->() const { return cb; }
        Mfea01UnregisterProtocol6CB(const Mfea01UnregisterProtocol6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01UnregisterProtocol6Rsp :
      public Mfea01UnregisterProtocol6CB {
        Mfea01UnregisterProtocol6Rsp(const Mfea01UnregisterProtocol6RF& cb)
          : Mfea01UnregisterProtocol6CB(cb) { }

    };

    virtual void async_mfea_0_1_unregister_protocol6
       (
    const string&   xrl_sender_name,
    const string&   if_name,
    const string&   vif_name,
    Mfea01UnregisterProtocol6CB);
#endif

    virtual XrlCmdError mfea_0_1_add_mfc6(
    // Input values,
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& iif_vif_index,
    const vector<uint8_t>&  oiflist,
    const vector<uint8_t>&  oiflist_disable_wrongvif,
    const uint32_t& max_vifs_oiflist,
    const IPv6& rp_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01AddMfc6RF;

    class Mfea01AddMfc6CB {
        Mfea01AddMfc6RF cb;

    public:
        operator const Mfea01AddMfc6RF& () const { return cb; }
        const Mfea01AddMfc6RF& operator ->() const { return cb; }
        Mfea01AddMfc6CB(const Mfea01AddMfc6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01AddMfc6Rsp :
      public Mfea01AddMfc6CB {
        Mfea01AddMfc6Rsp(const Mfea01AddMfc6RF& cb)
          : Mfea01AddMfc6CB(cb) { }

    };

    virtual void async_mfea_0_1_add_mfc6
       (
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& iif_vif_index,
    const vector<uint8_t>&  oiflist,
    const vector<uint8_t>&  oiflist_disable_wrongvif,
    const uint32_t& max_vifs_oiflist,
    const IPv6& rp_address,
    Mfea01AddMfc6CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_mfc6(
    // Input values,
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteMfc6RF;

    class Mfea01DeleteMfc6CB {
        Mfea01DeleteMfc6RF cb;

    public:
        operator const Mfea01DeleteMfc6RF& () const { return cb; }
        const Mfea01DeleteMfc6RF& operator ->() const { return cb; }
        Mfea01DeleteMfc6CB(const Mfea01DeleteMfc6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteMfc6Rsp :
      public Mfea01DeleteMfc6CB {
        Mfea01DeleteMfc6Rsp(const Mfea01DeleteMfc6RF& cb)
          : Mfea01DeleteMfc6CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_mfc6
       (
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    Mfea01DeleteMfc6CB);
#endif

    virtual XrlCmdError mfea_0_1_add_dataflow_monitor6(
    // Input values,
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01AddDataflowMonitor6RF;

    class Mfea01AddDataflowMonitor6CB {
        Mfea01AddDataflowMonitor6RF cb;

    public:
        operator const Mfea01AddDataflowMonitor6RF& () const { return cb; }
        const Mfea01AddDataflowMonitor6RF& operator ->() const { return cb; }
        Mfea01AddDataflowMonitor6CB(const Mfea01AddDataflowMonitor6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01AddDataflowMonitor6Rsp :
      public Mfea01AddDataflowMonitor6CB {
        Mfea01AddDataflowMonitor6Rsp(const Mfea01AddDataflowMonitor6RF& cb)
          : Mfea01AddDataflowMonitor6CB(cb) { }

    };

    virtual void async_mfea_0_1_add_dataflow_monitor6
       (
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall,
    Mfea01AddDataflowMonitor6CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_dataflow_monitor6(
    // Input values,
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteDataflowMonitor6RF;

    class Mfea01DeleteDataflowMonitor6CB {
        Mfea01DeleteDataflowMonitor6RF cb;

    public:
        operator const Mfea01DeleteDataflowMonitor6RF& () const { return cb; }
        const Mfea01DeleteDataflowMonitor6RF& operator ->() const { return cb; }
        Mfea01DeleteDataflowMonitor6CB(const Mfea01DeleteDataflowMonitor6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteDataflowMonitor6Rsp :
      public Mfea01DeleteDataflowMonitor6CB {
        Mfea01DeleteDataflowMonitor6Rsp(const Mfea01DeleteDataflowMonitor6RF& cb)
          : Mfea01DeleteDataflowMonitor6CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_dataflow_monitor6
       (
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    const uint32_t& threshold_interval_sec,
    const uint32_t& threshold_interval_usec,
    const uint32_t& threshold_packets,
    const uint32_t& threshold_bytes,
    const bool& is_threshold_in_packets,
    const bool& is_threshold_in_bytes,
    const bool& is_geq_upcall,
    const bool& is_leq_upcall,
    Mfea01DeleteDataflowMonitor6CB);
#endif

    virtual XrlCmdError mfea_0_1_delete_all_dataflow_monitor6(
    // Input values,
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address) = 0;
#ifdef XORP_ENABLE_ASYNC_SERVER
    typedef
    XorpCallback1<void, const XrlCmdError &>::RefPtr
    Mfea01DeleteAllDataflowMonitor6RF;

    class Mfea01DeleteAllDataflowMonitor6CB {
        Mfea01DeleteAllDataflowMonitor6RF cb;

    public:
        operator const Mfea01DeleteAllDataflowMonitor6RF& () const { return cb; }
        const Mfea01DeleteAllDataflowMonitor6RF& operator ->() const { return cb; }
        Mfea01DeleteAllDataflowMonitor6CB(const Mfea01DeleteAllDataflowMonitor6RF& cb)
          : cb(cb) { }

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

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

    struct Mfea01DeleteAllDataflowMonitor6Rsp :
      public Mfea01DeleteAllDataflowMonitor6CB {
        Mfea01DeleteAllDataflowMonitor6Rsp(const Mfea01DeleteAllDataflowMonitor6RF& cb)
          : Mfea01DeleteAllDataflowMonitor6CB(cb) { }

    };

    virtual void async_mfea_0_1_delete_all_dataflow_monitor6
       (
    const string&   xrl_sender_name,
    const IPv6& source_address,
    const IPv6& group_address,
    Mfea01DeleteAllDataflowMonitor6CB);
#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_cli_processor_0_1_process_command(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_cli_processor_0_1_process_command
       (const XrlCmdError &e,
    const string* arg_ret_processor_name,
    const string* arg_ret_cli_term_name,
    const uint32_t* arg_ret_cli_session_id,
    const string* arg_ret_command_output,
        XrlRespCallback);
#endif

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

    XrlCmdRT handle_ifmgr_replicator_0_1_unregister_ifmgr_mirror(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_ifmgr_replicator_0_1_unregister_ifmgr_mirror
       (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_mfea_0_1_have_multicast_routing4(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_mfea_0_1_have_multicast_routing4
       (const XrlCmdError &e,
    const bool* arg_result,
        XrlRespCallback);
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    XrlCmdRT handle_mfea_0_1_have_multicast_routing6(const XrlArgs& in, XrlCmdOT out);
#ifdef XORP_ENABLE_ASYNC_SERVER
    void callback_mfea_0_1_have_multicast_routing6
       (const XrlCmdError &e,
    const bool* arg_result,
        XrlRespCallback);
#endif

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

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

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

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

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

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

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

    void add_handlers();
    void remove_handlers();

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

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

#endif // __XRL_TARGETS_MFEA_BASE_HH__