ActiveLoggerComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  ActiveLoggerComponentAc.hpp
// \author Auto-generated
// \brief  hpp file for ActiveLogger component base class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
 
#ifndef ACTIVELOGGER_COMP_HPP_
#define ACTIVELOGGER_COMP_HPP_
 
#include <FpConfig.hpp>
#include <Fw/Port/InputSerializePort.hpp>
#include <Fw/Port/OutputSerializePort.hpp>
#include <Fw/Comp/ActiveComponentBase.hpp>
#include <Fw/Cmd/CmdString.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogString.hpp>
#include <Fw/Types/InternalInterfaceString.hpp>
#include <Fw/Log/LogBuffer.hpp>
#include <Fw/Time/Time.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Log/TextLogString.hpp>
#include <Fw/Log/LogPortAc.hpp>
#include <Fw/Com/ComPortAc.hpp>
#include <Svc/Fatal/FatalEventPortAc.hpp>
#include <Svc/Ping/PingPortAc.hpp>
#include <Fw/Cmd/CmdPortAc.hpp>
#include <Fw/Cmd/CmdResponsePortAc.hpp>
#include <Fw/Cmd/CmdRegPortAc.hpp>
#include <Fw/Time/TimePortAc.hpp>
#if FW_ENABLE_TEXT_LOGGING == 1
#include <Fw/Log/LogTextPortAc.hpp>
#endif
 
namespace Svc {
 
  class ActiveLoggerComponentBase :
    public Fw::ActiveComponentBase
  {
 
    // ----------------------------------------------------------------------
    // Friend classes
    // ----------------------------------------------------------------------
 
    friend class ActiveLoggerComponentBaseFriend;
 
  public:
 
    // ----------------------------------------------------------------------
    // Getters for typed input ports
    // ----------------------------------------------------------------------
 
    Fw::InputLogPort* get_LogRecv_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputPingPort* get_pingIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdPort* get_CmdDisp_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect typed input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_PktSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputComPort *port 
    );
 
    void set_FatalAnnounce_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputFatalEventPort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputPingPort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
    void set_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdRegPort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTimePort *port 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogPort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogTextPort *port 
    );
#endif
 
#if FW_PORT_SERIALIZATION
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect serialization input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_PktSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_FatalAnnounce_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
#endif
 
#endif
 
  public:
 
    // ----------------------------------------------------------------------
    // Command registration
    // ----------------------------------------------------------------------
 
    void regCommands(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Component construction, initialization, and destruction
    // ----------------------------------------------------------------------
 
#if FW_OBJECT_NAMES == 1
    ActiveLoggerComponentBase(
        const char* compName 
    );
#else
    ActiveLoggerComponentBase(void);
#endif
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    virtual ~ActiveLoggerComponentBase(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------
 
    //
    virtual void LogRecv_handler(
        NATIVE_INT_TYPE portNum, 
        FwEventIdType id, 
        Fw::Time &timeTag, 
        Fw::LogSeverity severity, 
        Fw::LogBuffer &args 
    ) = 0;
 
    //
    virtual void pingIn_handler(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Port handler base-class functions for typed input ports.
    // ----------------------------------------------------------------------
    // Call these functions directly to bypass the corresponding ports.
    // ----------------------------------------------------------------------
 
    void LogRecv_handlerBase(
        NATIVE_INT_TYPE portNum, 
        FwEventIdType id, 
        Fw::Time &timeTag, 
        Fw::LogSeverity severity, 
        Fw::LogBuffer &args 
    );
 
    void pingIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for typed async input ports.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing a message
    // on the corresponding port. By default they do nothing. You can
    // override them to provide specific pre-message behavior.
    // ----------------------------------------------------------------------
 
    virtual void pingIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Invocation functions for typed output ports
    // ----------------------------------------------------------------------
 
    void PktSend_out(
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    );
 
    void FatalAnnounce_out(
        NATIVE_INT_TYPE portNum, 
        FwEventIdType Id 
    );
 
    void pingOut_out(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of input ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_LogRecv_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_pingIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdDisp_InputPorts(void);
 
 
    // ----------------------------------------------------------------------
    // Enumerations for number of ports
    // ----------------------------------------------------------------------
 
    enum {
       NUM_LOGRECV_INPUT_PORTS = 1,
       NUM_PINGIN_INPUT_PORTS = 1,
       NUM_CMDDISP_INPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of output ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_PktSend_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_FatalAnnounce_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_pingOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdStatus_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdReg_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Time_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Log_OutputPorts(void);
 
#if FW_ENABLE_TEXT_LOGGING == 1
    NATIVE_INT_TYPE getNum_LogText_OutputPorts(void);
#endif
 
 
    enum {
       NUM_PKTSEND_OUTPUT_PORTS = 1,
       NUM_FATALANNOUNCE_OUTPUT_PORTS = 1,
       NUM_PINGOUT_OUTPUT_PORTS = 1,
       NUM_CMDSTATUS_OUTPUT_PORTS = 1,
       NUM_CMDREG_OUTPUT_PORTS = 1,
       NUM_TIME_OUTPUT_PORTS = 1,
       NUM_LOG_OUTPUT_PORTS = 1,
       NUM_LOGTEXT_OUTPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Connection status queries for output ports
    // ----------------------------------------------------------------------
 
    bool isConnected_PktSend_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_FatalAnnounce_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Time_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Log_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    bool isConnected_LogText_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
#endif
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      INPUT_WARNING_HI, /*  */
      INPUT_WARNING_LO, /*  */
      INPUT_COMMAND, /*  */
      INPUT_ACTIVITY_HI, /*  */
      INPUT_ACTIVITY_LO, /*  */
      INPUT_DIAGNOSTIC, /*  */
      InputFilterLevel_MAX
    } InputFilterLevel;
 
    typedef enum {
      INPUT_ENABLED, /*  */
      INPUT_DISABLED, /*  */
      InputFilterEnabled_MAX
    } InputFilterEnabled;
 
    typedef enum {
      SEND_WARNING_HI, /*  */
      SEND_WARNING_LO, /*  */
      SEND_COMMAND, /*  */
      SEND_ACTIVITY_HI, /*  */
      SEND_ACTIVITY_LO, /*  */
      SEND_DIAGNOSTIC, /*  */
      SendFilterLevel_MAX
    } SendFilterLevel;
 
    typedef enum {
      SEND_ENABLED, /*  */
      SEND_DISABLED, /*  */
      SendFilterEnabled_MAX
    } SendFilterEnabled;
 
    typedef enum {
      ID_ENABLED, /*  */
      ID_DISABLED, /*  */
      IdFilterEnabled_MAX
    } IdFilterEnabled;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command opcodes
    // ----------------------------------------------------------------------
 
    enum {
      OPCODE_ALOG_SET_EVENT_REPORT_FILTER = 0, /* Set filter for reporting events. Events are not stored in component. */
      OPCODE_ALOG_SET_EVENT_SEND_FILTER = 1, /* Set filter for sending events. Event will not be sent as a buffer. */
      OPCODE_ALOG_DUMP_EVENT_LOG = 2, /* Dump circular buffers of events to a file */
      OPCODE_ALOG_SET_ID_FILTER = 3, /* Filter a particular ID */
      OPCODE_ALOG_DUMP_FILTER_STATE = 4, /* Dump the filter states via events */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handlers to implement
    // ----------------------------------------------------------------------
 
    /* Set filter for reporting events. Events are not stored in component. */
    virtual void ALOG_SET_EVENT_REPORT_FILTER_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        InputFilterLevel FilterLevel, 
        InputFilterEnabled FilterEnable 
    ) = 0;
 
    /* Set filter for sending events. Event will not be sent as a buffer. */
    virtual void ALOG_SET_EVENT_SEND_FILTER_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        SendFilterLevel FilterLevel, 
        SendFilterEnabled FilterEnable 
    ) = 0;
 
    /* Dump circular buffers of events to a file */
    virtual void ALOG_DUMP_EVENT_LOG_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& filename 
    ) = 0;
 
    /* Filter a particular ID */
    virtual void ALOG_SET_ID_FILTER_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        U32 ID, 
        IdFilterEnabled IdFilterEnable 
    ) = 0;
 
    /* Dump the filter states via events */
    virtual void ALOG_DUMP_FILTER_STATE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for async commands.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing the
    // corresponding command. By default they do nothing. You can
    // override them to provide specific pre-command behavior.
    // ----------------------------------------------------------------------
 
    virtual void ALOG_DUMP_EVENT_LOG_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void ALOG_SET_ID_FILTER_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void ALOG_DUMP_FILTER_STATE_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handler base-class functions.
    // Call these functions directly to bypass the command input port.
    // ----------------------------------------------------------------------
 
    void ALOG_SET_EVENT_REPORT_FILTER_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void ALOG_SET_EVENT_SEND_FILTER_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void ALOG_DUMP_EVENT_LOG_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void ALOG_SET_ID_FILTER_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void ALOG_DUMP_FILTER_STATE_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command response
    // ----------------------------------------------------------------------
 
    void cmdResponse_out(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event IDs
    // ----------------------------------------------------------------------
 
    enum {
      EVENTID_ALOG_FILE_WRITE_ERR = 0, /* Failed to write circular buffer */
      EVENTID_ALOG_FILE_WRITE_COMPLETE = 1, /* Evemt log file write complete */
      EVENTID_ALOG_SEVERITY_FILTER_STATE = 2, /* Dump severity filter state */
      EVENTID_ALOG_ID_FILTER_ENABLED = 3, /* Indicate ID is filtered */
      EVENTID_ALOG_ID_FILTER_LIST_FULL = 4, /* Attempted to add ID to full ID filter ID */
      EVENTID_ALOG_ID_FILTER_REMOVED = 5, /* Removed an ID from the filter */
      EVENTID_ALOG_ID_FILTER_NOT_FOUND = 6, /* ID not in filter */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      LOG_WRITE_OPEN, /*  */
      LOG_WRITE_FATAL_DELIMETER, /*  */
      LOG_WRITE_FATAL_RECORD, /*  */
      LOG_WRITE_WARNING_HI_DELIMETER, /*  */
      LOG_WRITE_WARNING_HI_RECORD, /*  */
      LOG_WRITE_WARNING_LO_DELIMETER, /*  */
      LOG_WRITE_WARNING_LO_RECORD, /*  */
      LOG_WRITE_COMMAND_DELIMETER, /*  */
      LOG_WRITE_COMMAND_RECORD, /*  */
      LOG_WRITE_ACTIVITY_HI_DELIMETER, /*  */
      LOG_WRITE_ACTIVITY_HI_RECORD, /*  */
      LOG_WRITE_ACTIVITY_LO_DELIMETER, /*  */
      LOG_WRITE_ACTIVITY_LO_RECORD, /*  */
      LOG_WRITE_DIAGNOSTIC_DELIMETER, /*  */
      LOG_WRITE_DIAGNOSTIC_RECORD, /*  */
      LogWriteError_MAX
    } LogWriteError;
 
    typedef enum {
      EVENT_FILTER_WARNING_HI, /*  */
      EVENT_FILTER_WARNING_LO, /*  */
      EVENT_FILTER_COMMAND, /*  */
      EVENT_FILTER_ACTIVITY_HI, /*  */
      EVENT_FILTER_ACTIVITY_LO, /*  */
      EVENT_FILTER_DIAGNOSTIC, /*  */
      EventFilterState_MAX
    } EventFilterState;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event logging functions
    // ----------------------------------------------------------------------
 
    /* Failed to write circular buffer */
    void log_WARNING_HI_ALOG_FILE_WRITE_ERR(
        LogWriteError stage, 
        I32 error 
    );
 
 
    /* Evemt log file write complete */
    void log_ACTIVITY_HI_ALOG_FILE_WRITE_COMPLETE(
        U32 records 
    );
 
 
    /* Dump severity filter state */
    void log_ACTIVITY_LO_ALOG_SEVERITY_FILTER_STATE(
        EventFilterState severity, 
        bool recvEnabled, 
        bool sendEnabled 
    );
 
 
    /* Indicate ID is filtered */
    void log_ACTIVITY_HI_ALOG_ID_FILTER_ENABLED(
        U32 ID 
    );
 
 
    /* Attempted to add ID to full ID filter ID */
    void log_WARNING_LO_ALOG_ID_FILTER_LIST_FULL(
        U32 ID 
    );
 
 
    /* Removed an ID from the filter */
    void log_ACTIVITY_HI_ALOG_ID_FILTER_REMOVED(
        U32 ID 
    );
 
 
    /* ID not in filter */
    void log_WARNING_LO_ALOG_ID_FILTER_NOT_FOUND(
        U32 ID 
    );
 
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Time
    // ----------------------------------------------------------------------
 
    Fw::Time getTime(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Internal interface enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      QUEUE_LOG_FATAL = 1, /*  //<! A fatal non-recoverable event */
      QUEUE_LOG_WARNING_HI = 2, /*  //<! A serious but recoverable event */
      QUEUE_LOG_WARNING_LO = 3, /*  //<! A less serious but recoverable event */
      QUEUE_LOG_COMMAND = 4, /*  //<! An activity related to commanding */
      QUEUE_LOG_ACTIVITY_HI = 5, /*  //<! Important informational events */
      QUEUE_LOG_ACTIVITY_LO = 6, /*  //<! Less important informational events */
      QUEUE_LOG_DIAGNOSTIC = 7, /*  //<! Software diagnostic events */
      QueueLogSeverity_MAX
    } QueueLogSeverity;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Internal interface handlers
    // ----------------------------------------------------------------------
 
    virtual void loqQueue_internalInterfaceHandler(
        FwEventIdType id, 
        Fw::Time& timeTag, 
        QueueLogSeverity severity, 
        Fw::LogBuffer& args 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Internal interface base-class functions
    // ----------------------------------------------------------------------
 
    void loqQueue_internalInterfaceInvoke(
        FwEventIdType id, 
        Fw::Time& timeTag, 
        QueueLogSeverity severity, 
        Fw::LogBuffer& args 
    );
 
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed input ports
    // ----------------------------------------------------------------------
 
    Fw::InputLogPort m_LogRecv_InputPort[NUM_LOGRECV_INPUT_PORTS];
 
    Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS];
 
    Fw::InputCmdPort m_CmdDisp_InputPort[NUM_CMDDISP_INPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed output ports
    // ----------------------------------------------------------------------
 
    Fw::OutputComPort m_PktSend_OutputPort[NUM_PKTSEND_OUTPUT_PORTS];
 
    Svc::OutputFatalEventPort m_FatalAnnounce_OutputPort[NUM_FATALANNOUNCE_OUTPUT_PORTS];
 
    Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_CmdStatus_OutputPort[NUM_CMDSTATUS_OUTPUT_PORTS];
 
    Fw::OutputCmdRegPort m_CmdReg_OutputPort[NUM_CMDREG_OUTPUT_PORTS];
 
    Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS];
 
    Fw::OutputLogPort m_Log_OutputPort[NUM_LOG_OUTPUT_PORTS];
 
#if FW_ENABLE_TEXT_LOGGING == 1
    Fw::OutputLogTextPort m_LogText_OutputPort[NUM_LOGTEXT_OUTPUT_PORTS];
#endif
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Calls for messages received on typed input ports
    // ----------------------------------------------------------------------
 
    static void m_p_LogRecv_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwEventIdType id, 
        Fw::Time &timeTag, 
        Fw::LogSeverity severity, 
        Fw::LogBuffer &args 
    );
 
    static void m_p_pingIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    static void m_p_CmdDisp_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Message dispatch functions
    // ----------------------------------------------------------------------
 
    virtual MsgDispatchStatus doDispatch(void);
 
 
  PRIVATE:
    // ----------------------------------------------------------------------
    // Counter values for event throttling
    // ----------------------------------------------------------------------
 
  };
 
} // end namespace Svc
#endif