CfdpManagerComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  CfdpManagerComponentAc.hpp
// \author Generated by fpp-to-cpp
// \brief  hpp file for CfdpManager component base class
// ======================================================================

#ifndef Svc_Ccsds_Cfdp_CfdpManagerComponentAc_HPP
#define Svc_Ccsds_Cfdp_CfdpManagerComponentAc_HPP

#include <atomic>

#include "Fw/Buffer/BufferGetPortAc.hpp"
#include "Fw/Buffer/BufferSendPortAc.hpp"
#include "Fw/Cmd/CmdPortAc.hpp"
#include "Fw/Cmd/CmdRegPortAc.hpp"
#include "Fw/Cmd/CmdResponsePortAc.hpp"
#include "Fw/Cmd/CmdString.hpp"
#include "Fw/Comp/ActiveComponentBase.hpp"
#include "Fw/FPrimeBasicTypes.hpp"
#include "Fw/Log/LogPortAc.hpp"
#include "Fw/Log/LogString.hpp"
#include "Fw/Log/LogTextPortAc.hpp"
#if !FW_DIRECT_PORT_CALLS
#include "Fw/Port/InputSerializePort.hpp"
#endif
#if !FW_DIRECT_PORT_CALLS
#include "Fw/Port/OutputSerializePort.hpp"
#endif
#include "Fw/Prm/PrmGetPortAc.hpp"
#include "Fw/Prm/PrmSetPortAc.hpp"
#include "Fw/Prm/PrmString.hpp"
#include "Fw/Time/TimePortAc.hpp"
#include "Fw/Tlm/TlmPortAc.hpp"
#include "Fw/Tlm/TlmString.hpp"
#include "Os/Mutex.hpp"
#include "Svc/Ccsds/CfdpManager/Types/ChannelArrayParamsArrayAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/ChannelTelemetryArrayArrayAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/ClassEnumAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/FlowEnumAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/KeepEnumAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/PduTypeEnumEnumAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/RxDestPathRejectReasonEnumAc.hpp"
#include "Svc/Ccsds/CfdpManager/Types/SuspendResumeEnumAc.hpp"
#include "Svc/FileDownlinkPorts/SendFileCompletePortAc.hpp"
#include "Svc/FileDownlinkPorts/SendFileRequestPortAc.hpp"
#include "Svc/Ping/PingPortAc.hpp"
#include "Svc/Sched/SchedPortAc.hpp"
#include "default/config/EntityIdAliasAc.hpp"
#include "default/config/FwSizeStoreTypeAliasAc.hpp"
#include "default/config/FwSizeTypeAliasAc.hpp"
#include "default/config/TransactionSeqAliasAc.hpp"

namespace Svc {

  namespace Ccsds {

    namespace Cfdp {

      class CfdpManagerComponentBase :
        public Fw::ActiveComponentBase
      {

          // ----------------------------------------------------------------------
          // Friend classes
          // ----------------------------------------------------------------------

          friend class CfdpManagerTesterBase;
          friend class CfdpManagerTester;

        protected:

          // ----------------------------------------------------------------------
          // Constants
          // ----------------------------------------------------------------------

          enum {
            NUM_CMDIN_INPUT_PORTS = 1,
          };

          enum {
            NUM_DATAIN_INPUT_PORTS = 2,
            NUM_DATARETURNIN_INPUT_PORTS = 2,
            NUM_FILEIN_INPUT_PORTS = 1,
            NUM_PINGIN_INPUT_PORTS = 1,
            NUM_RUN1HZ_INPUT_PORTS = 1,
          };

          enum {
            NUM_CMDREGOUT_OUTPUT_PORTS = 1,
            NUM_CMDRESPONSEOUT_OUTPUT_PORTS = 1,
            NUM_LOGOUT_OUTPUT_PORTS = 1,
            NUM_LOGTEXTOUT_OUTPUT_PORTS = 1,
            NUM_PRMGETOUT_OUTPUT_PORTS = 1,
            NUM_PRMSETOUT_OUTPUT_PORTS = 1,
            NUM_TIMECALLER_OUTPUT_PORTS = 1,
            NUM_TLMOUT_OUTPUT_PORTS = 1,
          };

          enum {
            NUM_BUFFERALLOCATE_OUTPUT_PORTS = 2,
            NUM_BUFFERDEALLOCATE_OUTPUT_PORTS = 2,
            NUM_DATAINRETURN_OUTPUT_PORTS = 2,
            NUM_DATAOUT_OUTPUT_PORTS = 2,
            NUM_FILEDONEOUT_OUTPUT_PORTS = 1,
            NUM_PINGOUT_OUTPUT_PORTS = 1,
          };

          enum {
            OPCODE_SENDFILE = 0x0, 
            OPCODE_PLAYBACKDIRECTORY = 0x1, 
            OPCODE_POLLDIRECTORY = 0x2, 
            OPCODE_STOPPOLLDIRECTORY = 0x3, 
            OPCODE_SETCHANNELFLOW = 0x4, 
            OPCODE_SUSPENDRESUMETRANSACTION = 0x5, 
            OPCODE_CANCELTRANSACTION = 0x6, 
            OPCODE_ABANDONTRANSACTION = 0x7, 
            OPCODE_RESETCOUNTERS = 0x8, 
            OPCODE_LOCALEID_SET = 0x9, 
            OPCODE_LOCALEID_SAVE = 0xa, 
            OPCODE_OUTGOINGFILECHUNKSIZE_SET = 0xb, 
            OPCODE_OUTGOINGFILECHUNKSIZE_SAVE = 0xc, 
            OPCODE_RXCRCCALCBYTESPERCYCLE_SET = 0xd, 
            OPCODE_RXCRCCALCBYTESPERCYCLE_SAVE = 0xe, 
            OPCODE_POSTINACTIVITYSENDRETRIES_SET = 0xf, 
            OPCODE_POSTINACTIVITYSENDRETRIES_SAVE = 0x10, 
            OPCODE_FILEINDEFAULTCHANNEL_SET = 0x11, 
            OPCODE_FILEINDEFAULTCHANNEL_SAVE = 0x12, 
            OPCODE_FILEINDEFAULTDESTENTITYID_SET = 0x13, 
            OPCODE_FILEINDEFAULTDESTENTITYID_SAVE = 0x14, 
            OPCODE_FILEINDEFAULTCLASS_SET = 0x15, 
            OPCODE_FILEINDEFAULTCLASS_SAVE = 0x16, 
            OPCODE_FILEINDEFAULTKEEP_SET = 0x17, 
            OPCODE_FILEINDEFAULTKEEP_SAVE = 0x18, 
            OPCODE_FILEINDEFAULTPRIORITY_SET = 0x19, 
            OPCODE_FILEINDEFAULTPRIORITY_SAVE = 0x1a, 
            OPCODE_CHANNELCONFIG_SET = 0x1b, 
            OPCODE_CHANNELCONFIG_SAVE = 0x1c, 
          };

          enum {
            EVENTID_BUFFERSEXHAUSTED = 0x0,
            EVENTID_INVALIDCHANNEL = 0x1,
            EVENTID_TXFILEQUEUED = 0x2,
            EVENTID_UNSUPPORTEDSENDFILEARGUMENTS = 0x3,
            EVENTID_SENDFILEINITIATEFAIL = 0x4,
            EVENTID_PLAYBACKINITIATED = 0x5,
            EVENTID_POLLDIRINITIATED = 0x6,
            EVENTID_POLLDIRSTOPPED = 0x7,
            EVENTID_POLLDIRBUSY = 0x8,
            EVENTID_POLLDIRNOTACTIVE = 0x9,
            EVENTID_SETFLOWSTATE = 0xa,
            EVENTID_INVALIDCHANNELPOLL = 0xb,
            EVENTID_INVALIDPOLLINTERVAL = 0xc,
            EVENTID_FAILKEEPFILEMOVE = 0xd,
            EVENTID_FAILPOLLFILEMOVE = 0xe,
            EVENTID_FAILPDUHEADERDESERIALIZATION = 0xf,
            EVENTID_FAILPDUSERIALIZATION = 0x10,
            EVENTID_FAILMETADATAPDUDESERIALIZATION = 0x11,
            EVENTID_FAILFILEDATAPDUDESERIALIZATION = 0x12,
            EVENTID_FAILEOFPDUDESERIALIZATION = 0x13,
            EVENTID_FAILACKPDUDESERIALIZATION = 0x14,
            EVENTID_FAILFINPDUDESERIALIZATION = 0x15,
            EVENTID_FAILNAKPDUDESERIALIZATION = 0x16,
            EVENTID_RXACKLIMITREACHED = 0x17,
            EVENTID_RXTEMPFILECREATED = 0x18,
            EVENTID_RXFILECREATEFAILED = 0x19,
            EVENTID_RXDESTPATHREJECTED = 0x1a, 
            EVENTID_RXCRCMISMATCH = 0x1b,
            EVENTID_RXNAKLIMITREACHED = 0x1c,
            EVENTID_RXSEEKFAILED = 0x1d,
            EVENTID_RXWRITEFAILED = 0x1e,
            EVENTID_RXFILEDATAOUTOFBOUNDS = 0x1f,
            EVENTID_RXFILESIZEMISMATCH = 0x20,
            EVENTID_RXEOFCANCELRECEIVED = 0x21,
            EVENTID_RXEOFWITHERROR = 0x22,
            EVENTID_RXSEEKCRCFAILED = 0x23,
            EVENTID_RXREADCRCFAILED = 0x24,
            EVENTID_RXEOFMDSIZEMISMATCH = 0x25,
            EVENTID_RXFILERENAMEFAILED = 0x26,
            EVENTID_RXFILEREOPENFAILED = 0x27,
            EVENTID_RXINACTIVITYTIMEOUT = 0x28,
            EVENTID_RXINVALIDDIRECTIVECODE = 0x29,
            EVENTID_TXACKLIMITREACHED = 0x2a,
            EVENTID_TXINACTIVITYTIMEOUT = 0x2b,
            EVENTID_TXZEROLENGTHFILE = 0x2c,
            EVENTID_TXFILEOPENFAILED = 0x2d,
            EVENTID_TXFILESEEKFAILED = 0x2e,
            EVENTID_TXSENDMETADATAFAILED = 0x2f,
            EVENTID_TXEARLYFINRECEIVED = 0x30,
            EVENTID_TXINVALIDNAKPDU = 0x31,
            EVENTID_TXINVALIDSEGMENTREQUESTS = 0x32,
            EVENTID_TXNONFILEDIRECTIVEPDURECEIVED = 0x33,
            EVENTID_TXINVALIDDIRECTIVECODE = 0x34,
            EVENTID_TXFILETRANSFERSTARTED = 0x35,
            EVENTID_TXFILETRANSFERCOMPLETED = 0x36,
            EVENTID_TXFILETRANSFERFAILED = 0x37,
            EVENTID_RXFILETRANSFERCOMPLETED = 0x38,
            EVENTID_RXFILETRANSFERFAILED = 0x39,
            EVENTID_METADATARECEIVED = 0x3a,
            EVENTID_FILEDATASEGMENTMETADATA = 0x3b,
            EVENTID_CHUNKLISTUNAVAILABLE = 0x3c,
            EVENTID_UNHANDLEDPDUINIDLESTATE = 0x3d,
            EVENTID_RXTRANSACTIONLIMITREACHED = 0x3e,
            EVENTID_INVALIDDESTINATIONEID = 0x3f,
            EVENTID_MAXTXTRANSACTIONSREACHED = 0x40,
            EVENTID_PLAYBACKDIROPENFAILED = 0x41,
            EVENTID_PLAYBACKDIRSLOTUNAVAILABLE = 0x42,
            EVENTID_DANGLINGFILEHANDLECLOSED = 0x43,
            EVENTID_PLAYBACKDIRREADFAILED = 0x44,
            EVENTID_PLAYBACKSOURCEPATHTOOLONG = 0x45, 
            EVENTID_PLAYBACKDESTINATIONPATHTOOLONG = 0x46, 
            EVENTID_RESETFREEDTRANSACTION = 0x47,
            EVENTID_FILEREMOVEFAILED = 0x48,
            EVENTID_TRANSACTIONSUSPENDED = 0x49, 
            EVENTID_TRANSACTIONRESUMED = 0x4a, 
            EVENTID_TRANSACTIONCANCELED = 0x4b, 
            EVENTID_TRANSACTIONABANDONED = 0x4c, 
            EVENTID_TRANSACTIONNOTFOUND = 0x4d, 
            EVENTID_RESETCOUNTERS = 0x4e,
            EVENTID_TXLATEFINACKED = 0x4f, 
          };

          enum {
            CHANNELID_CHANNELTELEMETRY = 0x0, 
            CHANNELID_PRM_LOCAL_EID = 0x1, 
            CHANNELID_PRM_OUTGOING_FILE_CHUNK_SIZE = 0x2, 
            CHANNELID_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = 0x3, 
            CHANNELID_PRM_POST_INACTIVITY_SEND_RETRIES = 0x4, 
            CHANNELID_PRM_FILE_IN_DEFAULT_CHANNEL = 0x5, 
            CHANNELID_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = 0x6, 
            CHANNELID_PRM_FILE_IN_DEFAULT_CLASS = 0x7, 
            CHANNELID_PRM_FILE_IN_DEFAULT_KEEP = 0x8, 
            CHANNELID_PRM_FILE_IN_DEFAULT_PRIORITY = 0x9, 
            CHANNELID_PRM_CHANNEL_CONFIG = 0xa, 
          };

          enum {
            PARAMID_LOCALEID = 0x0, 
            PARAMID_OUTGOINGFILECHUNKSIZE = 0x1, 
            PARAMID_RXCRCCALCBYTESPERCYCLE = 0x2, 
            PARAMID_POSTINACTIVITYSENDRETRIES = 0x3, 
            PARAMID_FILEINDEFAULTCHANNEL = 0x4, 
            PARAMID_FILEINDEFAULTDESTENTITYID = 0x5, 
            PARAMID_FILEINDEFAULTCLASS = 0x6, 
            PARAMID_FILEINDEFAULTKEEP = 0x7, 
            PARAMID_FILEINDEFAULTPRIORITY = 0x8, 
            PARAMID_CHANNELCONFIG = 0x9, 
          };

        public:

          // ----------------------------------------------------------------------
          // Component initialization
          // ----------------------------------------------------------------------

          void init(
              FwSizeType queueDepth, 
              FwEnumStoreType instance = 0 
          );

#if !FW_DIRECT_PORT_CALLS

        public:

          // ----------------------------------------------------------------------
          // Getters for special input ports
          // ----------------------------------------------------------------------

          Fw::InputCmdPort* get_cmdIn_InputPort(
              FwIndexType portNum 
          );

#endif

#if !FW_DIRECT_PORT_CALLS

        public:

          // ----------------------------------------------------------------------
          // Getters for typed input ports
          // ----------------------------------------------------------------------

          Fw::InputBufferSendPort* get_dataIn_InputPort(
              FwIndexType portNum 
          );

          Fw::InputBufferSendPort* get_dataReturnIn_InputPort(
              FwIndexType portNum 
          );

          Svc::InputSendFileRequestPort* get_fileIn_InputPort(
              FwIndexType portNum 
          );

          Svc::InputPingPort* get_pingIn_InputPort(
              FwIndexType portNum 
          );

          Svc::InputSchedPort* get_run1Hz_InputPort(
              FwIndexType portNum 
          );

#endif

#if !FW_DIRECT_PORT_CALLS

        public:

          // ----------------------------------------------------------------------
          // Connect input ports to special output ports
          // ----------------------------------------------------------------------

          void set_cmdRegOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputCmdRegPort* port 
          );

          void set_cmdResponseOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputCmdResponsePort* port 
          );

          void set_logOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputLogPort* port 
          );

#if FW_ENABLE_TEXT_LOGGING == 1

          void set_logTextOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputLogTextPort* port 
          );

#endif

          void set_prmGetOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputPrmGetPort* port 
          );

          void set_prmSetOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputPrmSetPort* port 
          );

          void set_timeCaller_OutputPort(
              FwIndexType portNum, 
              Fw::InputTimePort* port 
          );

          void set_tlmOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputTlmPort* port 
          );

#endif

#if !FW_DIRECT_PORT_CALLS

        public:

          // ----------------------------------------------------------------------
          // Connect typed input ports to typed output ports
          // ----------------------------------------------------------------------

          void set_bufferAllocate_OutputPort(
              FwIndexType portNum, 
              Fw::InputBufferGetPort* port 
          );

          void set_bufferDeallocate_OutputPort(
              FwIndexType portNum, 
              Fw::InputBufferSendPort* port 
          );

          void set_dataInReturn_OutputPort(
              FwIndexType portNum, 
              Fw::InputBufferSendPort* port 
          );

          void set_dataOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputBufferSendPort* port 
          );

          void set_fileDoneOut_OutputPort(
              FwIndexType portNum, 
              Svc::InputSendFileCompletePort* port 
          );

          void set_pingOut_OutputPort(
              FwIndexType portNum, 
              Svc::InputPingPort* port 
          );

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

        public:

          // ----------------------------------------------------------------------
          // Connect serial input ports to special output ports
          // ----------------------------------------------------------------------

          void set_cmdRegOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_cmdResponseOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_logOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

#if FW_ENABLE_TEXT_LOGGING == 1

          void set_logTextOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

#endif

          void set_prmSetOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_timeCaller_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_tlmOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

        public:

          // ----------------------------------------------------------------------
          // Connect serial input ports to typed output ports
          // ----------------------------------------------------------------------

          void set_bufferDeallocate_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_dataInReturn_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_dataOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_fileDoneOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

          void set_pingOut_OutputPort(
              FwIndexType portNum, 
              Fw::InputSerializePort* port 
          );

#endif

        public:

          // ----------------------------------------------------------------------
          // Command registration
          // ----------------------------------------------------------------------

          void regCommands();

        public:

          // ----------------------------------------------------------------------
          // Parameter loading
          // ----------------------------------------------------------------------

          void loadParameters();

        protected:

          // ----------------------------------------------------------------------
          // Component construction and destruction
          // ----------------------------------------------------------------------

          CfdpManagerComponentBase(
              const char* compName = "" 
          );

          virtual ~CfdpManagerComponentBase();

        protected:

          // ----------------------------------------------------------------------
          // Getters for numbers of special input ports
          // ----------------------------------------------------------------------

          static constexpr FwIndexType getNum_cmdIn_InputPorts() {
            return NUM_CMDIN_INPUT_PORTS;
          }

        protected:

          // ----------------------------------------------------------------------
          // Getters for numbers of typed input ports
          // ----------------------------------------------------------------------

          static constexpr FwIndexType getNum_dataIn_InputPorts() {
            return NUM_DATAIN_INPUT_PORTS;
          }

          static constexpr FwIndexType getNum_dataReturnIn_InputPorts() {
            return NUM_DATARETURNIN_INPUT_PORTS;
          }

          static constexpr FwIndexType getNum_fileIn_InputPorts() {
            return NUM_FILEIN_INPUT_PORTS;
          }

          static constexpr FwIndexType getNum_pingIn_InputPorts() {
            return NUM_PINGIN_INPUT_PORTS;
          }

          static constexpr FwIndexType getNum_run1Hz_InputPorts() {
            return NUM_RUN1HZ_INPUT_PORTS;
          }

        protected:

          // ----------------------------------------------------------------------
          // Getters for numbers of special output ports
          // ----------------------------------------------------------------------

          static constexpr FwIndexType getNum_cmdRegOut_OutputPorts() {
            return NUM_CMDREGOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_cmdResponseOut_OutputPorts() {
            return NUM_CMDRESPONSEOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_logOut_OutputPorts() {
            return NUM_LOGOUT_OUTPUT_PORTS;
          }

#if FW_ENABLE_TEXT_LOGGING == 1

          static constexpr FwIndexType getNum_logTextOut_OutputPorts() {
            return NUM_LOGTEXTOUT_OUTPUT_PORTS;
          }

#endif

          static constexpr FwIndexType getNum_prmGetOut_OutputPorts() {
            return NUM_PRMGETOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_prmSetOut_OutputPorts() {
            return NUM_PRMSETOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_timeCaller_OutputPorts() {
            return NUM_TIMECALLER_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_tlmOut_OutputPorts() {
            return NUM_TLMOUT_OUTPUT_PORTS;
          }

        protected:

          // ----------------------------------------------------------------------
          // Getters for numbers of typed output ports
          // ----------------------------------------------------------------------

          static constexpr FwIndexType getNum_bufferAllocate_OutputPorts() {
            return NUM_BUFFERALLOCATE_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_bufferDeallocate_OutputPorts() {
            return NUM_BUFFERDEALLOCATE_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_dataInReturn_OutputPorts() {
            return NUM_DATAINRETURN_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_dataOut_OutputPorts() {
            return NUM_DATAOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_fileDoneOut_OutputPorts() {
            return NUM_FILEDONEOUT_OUTPUT_PORTS;
          }

          static constexpr FwIndexType getNum_pingOut_OutputPorts() {
            return NUM_PINGOUT_OUTPUT_PORTS;
          }

        protected:

          // ----------------------------------------------------------------------
          // Connection status queries for special output ports
          // ----------------------------------------------------------------------

          bool isConnected_cmdRegOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_cmdResponseOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_logOut_OutputPort(
              FwIndexType portNum 
          ) const;

#if FW_ENABLE_TEXT_LOGGING == 1

          bool isConnected_logTextOut_OutputPort(
              FwIndexType portNum 
          ) const;

#endif

          bool isConnected_prmGetOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_prmSetOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_timeCaller_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_tlmOut_OutputPort(
              FwIndexType portNum 
          ) const;

        protected:

          // ----------------------------------------------------------------------
          // Connection status queries for typed output ports
          // ----------------------------------------------------------------------

          bool isConnected_bufferAllocate_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_bufferDeallocate_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_dataInReturn_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_dataOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_fileDoneOut_OutputPort(
              FwIndexType portNum 
          ) const;

          bool isConnected_pingOut_OutputPort(
              FwIndexType portNum 
          ) const;

#if FW_DIRECT_PORT_CALLS
        public:
#else
        protected:
#endif

          // ----------------------------------------------------------------------
          // Port handler base-class functions for special input ports
          //
          // Call these functions directly to bypass the corresponding ports
          // ----------------------------------------------------------------------

          void cmdIn_handlerBase(
              FwIndexType portNum, 
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

        protected:

          // ----------------------------------------------------------------------
          // Handlers to implement for typed input ports
          // ----------------------------------------------------------------------

          virtual void dataIn_handler(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          ) = 0;

          virtual void dataReturnIn_handler(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          ) = 0;

          virtual Svc::SendFileResponse fileIn_handler(
              FwIndexType portNum, 
              const Fw::StringBase& sourceFileName, 
              const Fw::StringBase& destFileName, 
              U32 offset, 
              U32 length 
          ) = 0;

          virtual void pingIn_handler(
              FwIndexType portNum, 
              U32 key 
          ) = 0;

          virtual void run1Hz_handler(
              FwIndexType portNum, 
              U32 context 
          ) = 0;

#if FW_DIRECT_PORT_CALLS
        public:
#else
        protected:
#endif

          // ----------------------------------------------------------------------
          // Port handler base-class functions for typed input ports
          //
          // Call these functions directly to bypass the corresponding ports
          // ----------------------------------------------------------------------

          void dataIn_handlerBase(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          void dataReturnIn_handlerBase(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          Svc::SendFileResponse fileIn_handlerBase(
              FwIndexType portNum, 
              const Fw::StringBase& sourceFileName, 
              const Fw::StringBase& destFileName, 
              U32 offset, 
              U32 length 
          );

          void pingIn_handlerBase(
              FwIndexType portNum, 
              U32 key 
          );

          void run1Hz_handlerBase(
              FwIndexType portNum, 
              U32 context 
          );

        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 dataIn_preMsgHook(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          virtual void dataReturnIn_preMsgHook(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          virtual void pingIn_preMsgHook(
              FwIndexType portNum, 
              U32 key 
          );

          virtual void run1Hz_preMsgHook(
              FwIndexType portNum, 
              U32 context 
          );

        protected:

          // ----------------------------------------------------------------------
          // Invocation functions for typed output ports
          // ----------------------------------------------------------------------

          Fw::Buffer bufferAllocate_out(
              FwIndexType portNum, 
              FwSizeType size 
          ) const;

          void bufferDeallocate_out(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          ) const;

          void dataInReturn_out(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          ) const;

          void dataOut_out(
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          ) const;

          void fileDoneOut_out(
              FwIndexType portNum, 
              const Svc::SendFileResponse& resp
          ) const;

          void pingOut_out(
              FwIndexType portNum, 
              U32 key 
          ) const;

        protected:

          // ----------------------------------------------------------------------
          // Command response
          // ----------------------------------------------------------------------

          void cmdResponse_out(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdResponse response 
          );

        protected:

          // ----------------------------------------------------------------------
          // Command handlers to implement
          // ----------------------------------------------------------------------

          virtual void SendFile_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              Svc::Ccsds::Cfdp::EntityId destId, 
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              const Svc::Ccsds::Cfdp::Keep& keep, 
              U8 priority, 
              const Fw::CmdStringArg& sourceFileName, 
              const Fw::CmdStringArg& destFileName 
          ) = 0;

          virtual void PlaybackDirectory_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              Svc::Ccsds::Cfdp::EntityId destId, 
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              const Svc::Ccsds::Cfdp::Keep& keep, 
              U8 priority, 
              const Fw::CmdStringArg& sourceDirectory, 
              const Fw::CmdStringArg& destDirectory 
          ) = 0;

          virtual void PollDirectory_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              U8 pollId, 
              Svc::Ccsds::Cfdp::EntityId destId, 
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U8 priority, 
              U32 interval, 
              const Fw::CmdStringArg& sourceDirectory, 
              const Fw::CmdStringArg& destDirectory 
          ) = 0;

          virtual void StopPollDirectory_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              U8 pollId 
          ) = 0;

          virtual void SetChannelFlow_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              const Svc::Ccsds::Cfdp::Flow& freeze 
          ) = 0;

          virtual void SuspendResumeTransaction_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId, 
              const Svc::Ccsds::Cfdp::SuspendResume& action 
          ) = 0;

          virtual void CancelTransaction_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) = 0;

          virtual void AbandonTransaction_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId, 
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) = 0;

          virtual void ResetCounters_cmdHandler(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              U8 channelId 
          ) = 0;

        protected:

          // ----------------------------------------------------------------------
          // Command handler base-class functions
          //
          // Call these functions directly to bypass the command input port
          // ----------------------------------------------------------------------

          void SendFile_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void PlaybackDirectory_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void PollDirectory_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void StopPollDirectory_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void SetChannelFlow_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void SuspendResumeTransaction_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void CancelTransaction_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void AbandonTransaction_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

          void ResetCounters_cmdHandlerBase(
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

        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 SendFile_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void PlaybackDirectory_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void PollDirectory_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void StopPollDirectory_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void SetChannelFlow_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void SuspendResumeTransaction_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void CancelTransaction_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void AbandonTransaction_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

          virtual void ResetCounters_preMsgHook(
              FwOpcodeType opCode, 
              U32 cmdSeq 
          );

        protected:

          // ----------------------------------------------------------------------
          // Event logging functions
          // ----------------------------------------------------------------------

          void log_WARNING_LO_BuffersExhausted() const;

          void log_WARNING_LO_InvalidChannel(
              U8 channelId, 
              U8 maxChannelId 
          ) const;

          void log_ACTIVITY_LO_TxFileQueued(
              const Fw::StringBase& sourceFileName, 
              U32 transactionSeq 
          ) const;

          void log_WARNING_LO_UnsupportedSendFileArguments(
              U32 offset, 
              U32 length 
          ) const;

          void log_WARNING_LO_SendFileInitiateFail(
              const Fw::StringBase& sourceFileName 
          ) const;

          void log_ACTIVITY_LO_PlaybackInitiated(
              const Fw::StringBase& sourceDirectory 
          ) const;

          void log_ACTIVITY_LO_PollDirInitiated(
              const Fw::StringBase& sourceDirectory, 
              U8 pollId 
          ) const;

          void log_ACTIVITY_LO_PollDirStopped(
              U8 channelId, 
              U8 pollId 
          ) const;

          void log_WARNING_LO_PollDirBusy(
              U8 channelId, 
              U8 pollId 
          ) const;

          void log_WARNING_LO_PollDirNotActive(
              U8 channelId, 
              U8 pollId 
          ) const;

          void log_ACTIVITY_LO_SetFlowState(
              U8 channelId, 
              const Svc::Ccsds::Cfdp::Flow& flowState 
          ) const;

          void log_WARNING_LO_InvalidChannelPoll(
              U8 pollId, 
              U8 maxPollId 
          ) const;

          void log_WARNING_LO_InvalidPollInterval(
              U32 interval 
          ) const;

          void log_WARNING_LO_FailKeepFileMove(
              const Fw::StringBase& srcFile, 
              const Fw::StringBase& moveDir, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailPollFileMove(
              const Fw::StringBase& srcFile, 
              const Fw::StringBase& failDir, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailPduHeaderDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailPduSerialization(
              U8 channelId, 
              const Svc::Ccsds::Cfdp::PduTypeEnum& pduType, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailMetadataPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailFileDataPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailEofPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailAckPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailFinPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_FailNakPduDeserialization(
              U8 channelId, 
              I32 status 
          ) const;

          void log_WARNING_LO_RxAckLimitReached(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_ACTIVITY_LO_RxTempFileCreated(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename 
          ) const;

          void log_WARNING_LO_RxFileCreateFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename, 
              I32 status 
          ) const;

          void log_WARNING_HI_RxDestPathRejected(
              U8 channelId, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename, 
              const Fw::StringBase& rxDir, 
              const Svc::Ccsds::Cfdp::RxDestPathRejectReason& reason 
          ) const;

          void log_WARNING_LO_RxCrcMismatch(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 expected, 
              U32 actual 
          ) const;

          void log_WARNING_LO_RxNakLimitReached(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_RxSeekFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 offset, 
              I32 status 
          ) const;

          void log_WARNING_LO_RxWriteFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 expected, 
              I32 actual 
          ) const;

          void log_WARNING_LO_RxFileDataOutOfBounds(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 offset, 
              U32 dataSize, 
              U32 fileSize 
          ) const;

          void log_WARNING_LO_RxFileSizeMismatch(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 expected, 
              U32 actual 
          ) const;

          void log_ACTIVITY_HI_RxEofCancelReceived(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_RxEofWithError(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U8 conditionCode 
          ) const;

          void log_WARNING_LO_RxSeekCrcFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 offset, 
              I32 status 
          ) const;

          void log_WARNING_LO_RxReadCrcFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 expected, 
              I32 actual 
          ) const;

          void log_WARNING_LO_RxEofMdSizeMismatch(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 mdSize, 
              U32 eofSize 
          ) const;

          void log_WARNING_LO_RxFileRenameFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& tempFile, 
              const Fw::StringBase& finalFile, 
              I32 status 
          ) const;

          void log_WARNING_LO_RxFileReopenFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename, 
              I32 status 
          ) const;

          void log_WARNING_LO_RxInactivityTimeout(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_RxInvalidDirectiveCode(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U8 directiveCode, 
              U8 substate 
          ) const;

          void log_WARNING_LO_TxAckLimitReached(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxInactivityTimeout(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxZeroLengthFile(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename 
          ) const;

          void log_WARNING_LO_TxFileOpenFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              const Fw::StringBase& filename, 
              I32 status 
          ) const;

          void log_WARNING_LO_TxFileSeekFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              I32 status 
          ) const;

          void log_WARNING_LO_TxSendMetadataFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxEarlyFinReceived(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxInvalidNakPdu(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxInvalidSegmentRequests(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U32 badCount 
          ) const;

          void log_WARNING_LO_TxNonFileDirectivePduReceived(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum 
          ) const;

          void log_WARNING_LO_TxInvalidDirectiveCode(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 srcEid, 
              U32 seqNum, 
              U8 directiveCode, 
              U8 substate 
          ) const;

          void log_ACTIVITY_HI_TxFileTransferStarted(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 seqNum, 
              U32 srcEid, 
              const Fw::StringBase& srcFile, 
              U32 destEid, 
              const Fw::StringBase& destFile, 
              U32 fileSize 
          ) const;

          void log_ACTIVITY_HI_TxFileTransferCompleted(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 seqNum, 
              U32 srcEid, 
              const Fw::StringBase& srcFile, 
              U32 destEid, 
              const Fw::StringBase& destFile, 
              U32 fileSize 
          ) const;

          void log_WARNING_LO_TxFileTransferFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 seqNum, 
              U32 srcEid, 
              const Fw::StringBase& srcFile, 
              U32 destEid, 
              const Fw::StringBase& destFile, 
              U8 conditionCode 
          ) const;

          void log_ACTIVITY_HI_RxFileTransferCompleted(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 seqNum, 
              U32 srcEid, 
              const Fw::StringBase& srcFile, 
              U32 destEid, 
              const Fw::StringBase& destFile, 
              U32 fileSize 
          ) const;

          void log_WARNING_LO_RxFileTransferFailed(
              const Svc::Ccsds::Cfdp::Class& cfdpClass, 
              U32 seqNum, 
              U32 srcEid, 
              const Fw::StringBase& srcFile, 
              U32 destEid, 
              const Fw::StringBase& destFile, 
              U8 conditionCode 
          ) const;

          void log_ACTIVITY_LO_MetadataReceived(
              const Fw::StringBase& srcFile, 
              const Fw::StringBase& destFile, 
              U32 transactionSeq 
          ) const;

          void log_WARNING_LO_FileDataSegmentMetadata() const;

          void log_WARNING_LO_ChunklistUnavailable(
              U32 transactionSeq 
          ) const;

          void log_WARNING_LO_UnhandledPduInIdleState() const;

          void log_WARNING_LO_RxTransactionLimitReached(
              U32 srcEid, 
              U32 transactionSeq 
          ) const;

          void log_WARNING_LO_InvalidDestinationEid(
              U32 destEid 
          ) const;

          void log_WARNING_LO_MaxTxTransactionsReached() const;

          void log_WARNING_LO_PlaybackDirOpenFailed(
              const Fw::StringBase& directory, 
              I32 status 
          ) const;

          void log_WARNING_LO_PlaybackDirSlotUnavailable() const;

          void log_WARNING_LO_DanglingFileHandleClosed(
              U8 channelId, 
              U32 transactionSeq 
          ) const;

          void log_WARNING_LO_PlaybackDirReadFailed(
              const Fw::StringBase& directory, 
              I32 status 
          ) const;

          void log_WARNING_LO_PlaybackSourcePathTooLong(
              FwSizeType length, 
              FwSizeType maxLength, 
              const Fw::StringBase& directory, 
              const Fw::StringBase& entry 
          ) const;

          void log_WARNING_LO_PlaybackDestinationPathTooLong(
              FwSizeType length, 
              FwSizeType maxLength, 
              const Fw::StringBase& directory, 
              const Fw::StringBase& entry 
          ) const;

          void log_DIAGNOSTIC_ResetFreedTransaction() const;

          void log_WARNING_LO_FileRemoveFailed(
              const Fw::StringBase& filename, 
              I32 status 
          ) const;

          void log_ACTIVITY_LO_TransactionSuspended(
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) const;

          void log_ACTIVITY_LO_TransactionResumed(
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) const;

          void log_ACTIVITY_HI_TransactionCanceled(
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) const;

          void log_ACTIVITY_HI_TransactionAbandoned(
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) const;

          void log_WARNING_LO_TransactionNotFound(
              Svc::Ccsds::Cfdp::TransactionSeq transactionSeq, 
              Svc::Ccsds::Cfdp::EntityId entityId 
          ) const;

          void log_ACTIVITY_HI_ResetCounters(
              U8 channelId 
          ) const;

          void log_DIAGNOSTIC_TxLateFinAcked(
              Svc::Ccsds::Cfdp::EntityId srcEid, 
              Svc::Ccsds::Cfdp::TransactionSeq seqNum 
          ) const;

        protected:

          // ----------------------------------------------------------------------
          // Telemetry serialized write
          // ----------------------------------------------------------------------

          void tlmWrite(
              FwChanIdType id, 
              Fw::TlmBuffer& _tlmBuff, 
              Fw::Time _tlmTime = Fw::Time() 
          ) const;

        protected:

          // ----------------------------------------------------------------------
          // Telemetry write functions
          // ----------------------------------------------------------------------

          void tlmWrite_ChannelTelemetry(
              const Svc::Ccsds::Cfdp::ChannelTelemetryArray& arg, 
              Fw::Time _tlmTime = Fw::Time() 
          ) const;

          void tlmWrite_PRM_LOCAL_EID(
              Svc::Ccsds::Cfdp::EntityId arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_OUTGOING_FILE_CHUNK_SIZE(
              U32 arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_RX_CRC_CALC_BYTES_PER_CYCLE(
              U32 arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_POST_INACTIVITY_SEND_RETRIES(
              U8 arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_FILE_IN_DEFAULT_CHANNEL(
              U8 arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID(
              Svc::Ccsds::Cfdp::EntityId arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_FILE_IN_DEFAULT_CLASS(
              const Svc::Ccsds::Cfdp::Class& arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_FILE_IN_DEFAULT_KEEP(
              const Svc::Ccsds::Cfdp::Keep& arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_FILE_IN_DEFAULT_PRIORITY(
              U8 arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

          void tlmWrite_PRM_CHANNEL_CONFIG(
              const Svc::Ccsds::Cfdp::ChannelArrayParams& arg, 
              Fw::Time _tlmTime = Fw::Time() 
          );

        protected:

          // ----------------------------------------------------------------------
          // Parameter hook functions
          // ----------------------------------------------------------------------

          virtual void parameterUpdated(
              FwPrmIdType id 
          );

          virtual void parametersLoaded();

          virtual void parameterLoaded(
              FwPrmIdType id, 
              Fw::ParamValid valid 
          );

        protected:

          // ----------------------------------------------------------------------
          // Parameter get functions
          // ----------------------------------------------------------------------

          Svc::Ccsds::Cfdp::EntityId paramGet_LocalEid(
              Fw::ParamValid& valid 
          );

          U32 paramGet_OutgoingFileChunkSize(
              Fw::ParamValid& valid 
          );

          U32 paramGet_RxCrcCalcBytesPerCycle(
              Fw::ParamValid& valid 
          );

          U8 paramGet_PostInactivitySendRetries(
              Fw::ParamValid& valid 
          );

          U8 paramGet_FileInDefaultChannel(
              Fw::ParamValid& valid 
          );

          Svc::Ccsds::Cfdp::EntityId paramGet_FileInDefaultDestEntityId(
              Fw::ParamValid& valid 
          );

          Svc::Ccsds::Cfdp::Class paramGet_FileInDefaultClass(
              Fw::ParamValid& valid 
          );

          Svc::Ccsds::Cfdp::Keep paramGet_FileInDefaultKeep(
              Fw::ParamValid& valid 
          );

          U8 paramGet_FileInDefaultPriority(
              Fw::ParamValid& valid 
          );

          Svc::Ccsds::Cfdp::ChannelArrayParams paramGet_ChannelConfig(
              Fw::ParamValid& valid 
          );

        protected:

          // ----------------------------------------------------------------------
          // Time
          // ----------------------------------------------------------------------

          Fw::Time getTime() const;

        protected:

          // ----------------------------------------------------------------------
          // Mutex operations for guarded ports
          //
          // You can override these operations to provide more sophisticated
          // synchronization
          // ----------------------------------------------------------------------

          virtual void lock();

          virtual void unLock();

        private:

          // ----------------------------------------------------------------------
          // Message dispatch functions
          // ----------------------------------------------------------------------

          virtual MsgDispatchStatus doDispatch();

        private:

          // ----------------------------------------------------------------------
          // Calls for messages received on special input ports
          // ----------------------------------------------------------------------

          static void m_p_cmdIn_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              Fw::CmdArgBuffer& args 
          );

        private:

          // ----------------------------------------------------------------------
          // Calls for messages received on typed input ports
          // ----------------------------------------------------------------------

          static void m_p_dataIn_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          static void m_p_dataReturnIn_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              Fw::Buffer& fwBuffer 
          );

          static Svc::SendFileResponse m_p_fileIn_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              const Fw::StringBase& sourceFileName, 
              const Fw::StringBase& destFileName, 
              U32 offset, 
              U32 length 
          );

          static void m_p_pingIn_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              U32 key 
          );

          static void m_p_run1Hz_in(
              Fw::PassiveComponentBase* callComp, 
              FwIndexType portNum, 
              U32 context 
          );

        private:

          // ----------------------------------------------------------------------
          // Invocation functions for special output ports
          // ----------------------------------------------------------------------

          void cmdRegOut_out(
              FwIndexType portNum, 
              FwOpcodeType opCode 
          ) const;

          void cmdResponseOut_out(
              FwIndexType portNum, 
              FwOpcodeType opCode, 
              U32 cmdSeq, 
              const Fw::CmdResponse& response 
          ) const;

          void logOut_out(
              FwIndexType portNum, 
              FwEventIdType id, 
              Fw::Time& timeTag, 
              const Fw::LogSeverity& severity, 
              Fw::LogBuffer& args 
          ) const;

#if FW_ENABLE_TEXT_LOGGING

          void logTextOut_out(
              FwIndexType portNum, 
              FwEventIdType id, 
              Fw::Time& timeTag, 
              const Fw::LogSeverity& severity, 
              Fw::TextLogString& text 
          ) const;

#endif

          Fw::ParamValid prmGetOut_out(
              FwIndexType portNum, 
              FwPrmIdType id, 
              Fw::ParamBuffer& val 
          ) const;

          void prmSetOut_out(
              FwIndexType portNum, 
              FwPrmIdType id, 
              Fw::ParamBuffer& val 
          ) const;

          void timeCaller_out(
              FwIndexType portNum, 
              Fw::Time& time 
          ) const;

          void tlmOut_out(
              FwIndexType portNum, 
              FwChanIdType id, 
              Fw::Time& timeTag, 
              Fw::TlmBuffer& val 
          ) const;

        private:

          // ----------------------------------------------------------------------
          // Parameter set functions
          // ----------------------------------------------------------------------

          Fw::CmdResponse paramSet_LocalEid(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_OutgoingFileChunkSize(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_RxCrcCalcBytesPerCycle(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_PostInactivitySendRetries(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_FileInDefaultChannel(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_FileInDefaultDestEntityId(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_FileInDefaultClass(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_FileInDefaultKeep(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_FileInDefaultPriority(
              Fw::SerialBufferBase& val 
          );

          Fw::CmdResponse paramSet_ChannelConfig(
              Fw::SerialBufferBase& val 
          );

        private:

          // ----------------------------------------------------------------------
          // Parameter save functions
          // ----------------------------------------------------------------------

          Fw::CmdResponse paramSave_LocalEid();

          Fw::CmdResponse paramSave_OutgoingFileChunkSize();

          Fw::CmdResponse paramSave_RxCrcCalcBytesPerCycle();

          Fw::CmdResponse paramSave_PostInactivitySendRetries();

          Fw::CmdResponse paramSave_FileInDefaultChannel();

          Fw::CmdResponse paramSave_FileInDefaultDestEntityId();

          Fw::CmdResponse paramSave_FileInDefaultClass();

          Fw::CmdResponse paramSave_FileInDefaultKeep();

          Fw::CmdResponse paramSave_FileInDefaultPriority();

          Fw::CmdResponse paramSave_ChannelConfig();

#if !FW_DIRECT_PORT_CALLS

        private:

          // ----------------------------------------------------------------------
          // Special input ports
          // ----------------------------------------------------------------------

          Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

        private:

          // ----------------------------------------------------------------------
          // Typed input ports
          // ----------------------------------------------------------------------

          Fw::InputBufferSendPort m_dataIn_InputPort[NUM_DATAIN_INPUT_PORTS];

          Fw::InputBufferSendPort m_dataReturnIn_InputPort[NUM_DATARETURNIN_INPUT_PORTS];

          Svc::InputSendFileRequestPort m_fileIn_InputPort[NUM_FILEIN_INPUT_PORTS];

          Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS];

          Svc::InputSchedPort m_run1Hz_InputPort[NUM_RUN1HZ_INPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

        private:

          // ----------------------------------------------------------------------
          // Special output ports
          // ----------------------------------------------------------------------

          Fw::OutputCmdRegPort m_cmdRegOut_OutputPort[NUM_CMDREGOUT_OUTPUT_PORTS];

          Fw::OutputCmdResponsePort m_cmdResponseOut_OutputPort[NUM_CMDRESPONSEOUT_OUTPUT_PORTS];

          Fw::OutputLogPort m_logOut_OutputPort[NUM_LOGOUT_OUTPUT_PORTS];

#if FW_ENABLE_TEXT_LOGGING == 1

          Fw::OutputLogTextPort m_logTextOut_OutputPort[NUM_LOGTEXTOUT_OUTPUT_PORTS];

#endif

          Fw::OutputPrmGetPort m_prmGetOut_OutputPort[NUM_PRMGETOUT_OUTPUT_PORTS];

          Fw::OutputPrmSetPort m_prmSetOut_OutputPort[NUM_PRMSETOUT_OUTPUT_PORTS];

          Fw::OutputTimePort m_timeCaller_OutputPort[NUM_TIMECALLER_OUTPUT_PORTS];

          Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

        private:

          // ----------------------------------------------------------------------
          // Typed output ports
          // ----------------------------------------------------------------------

          Fw::OutputBufferGetPort m_bufferAllocate_OutputPort[NUM_BUFFERALLOCATE_OUTPUT_PORTS];

          Fw::OutputBufferSendPort m_bufferDeallocate_OutputPort[NUM_BUFFERDEALLOCATE_OUTPUT_PORTS];

          Fw::OutputBufferSendPort m_dataInReturn_OutputPort[NUM_DATAINRETURN_OUTPUT_PORTS];

          Fw::OutputBufferSendPort m_dataOut_OutputPort[NUM_DATAOUT_OUTPUT_PORTS];

          Svc::OutputSendFileCompletePort m_fileDoneOut_OutputPort[NUM_FILEDONEOUT_OUTPUT_PORTS];

          Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];

#endif

        private:

          // ----------------------------------------------------------------------
          // First update flags for telemetry channels
          // ----------------------------------------------------------------------

          bool m_first_update_PRM_LOCAL_EID = true;

          bool m_first_update_PRM_OUTGOING_FILE_CHUNK_SIZE = true;

          bool m_first_update_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = true;

          bool m_first_update_PRM_POST_INACTIVITY_SEND_RETRIES = true;

          bool m_first_update_PRM_FILE_IN_DEFAULT_CHANNEL = true;

          bool m_first_update_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = true;

          bool m_first_update_PRM_FILE_IN_DEFAULT_CLASS = true;

          bool m_first_update_PRM_FILE_IN_DEFAULT_KEEP = true;

          bool m_first_update_PRM_FILE_IN_DEFAULT_PRIORITY = true;

          bool m_first_update_PRM_CHANNEL_CONFIG = true;

        private:

          // ----------------------------------------------------------------------
          // Last value storage for telemetry channels
          // ----------------------------------------------------------------------

          Svc::Ccsds::Cfdp::EntityId m_last_PRM_LOCAL_EID = {};

          U32 m_last_PRM_OUTGOING_FILE_CHUNK_SIZE = {};

          U32 m_last_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = {};

          U8 m_last_PRM_POST_INACTIVITY_SEND_RETRIES = {};

          U8 m_last_PRM_FILE_IN_DEFAULT_CHANNEL = {};

          Svc::Ccsds::Cfdp::EntityId m_last_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = {};

          Svc::Ccsds::Cfdp::Class m_last_PRM_FILE_IN_DEFAULT_CLASS = {};

          Svc::Ccsds::Cfdp::Keep m_last_PRM_FILE_IN_DEFAULT_KEEP = {};

          U8 m_last_PRM_FILE_IN_DEFAULT_PRIORITY = {};

          Svc::Ccsds::Cfdp::ChannelArrayParams m_last_PRM_CHANNEL_CONFIG = {};

        private:

          // ----------------------------------------------------------------------
          // Parameter validity flags
          // ----------------------------------------------------------------------

          Fw::ParamValid m_param_LocalEid_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_OutgoingFileChunkSize_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_RxCrcCalcBytesPerCycle_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_PostInactivitySendRetries_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_FileInDefaultChannel_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_FileInDefaultDestEntityId_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_FileInDefaultClass_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_FileInDefaultKeep_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_FileInDefaultPriority_valid = Fw::ParamValid::UNINIT;

          Fw::ParamValid m_param_ChannelConfig_valid = Fw::ParamValid::UNINIT;

        private:

          // ----------------------------------------------------------------------
          // Parameter variables
          // ----------------------------------------------------------------------

          Svc::Ccsds::Cfdp::EntityId m_LocalEid;

          U32 m_OutgoingFileChunkSize;

          U32 m_RxCrcCalcBytesPerCycle;

          U8 m_PostInactivitySendRetries;

          U8 m_FileInDefaultChannel;

          Svc::Ccsds::Cfdp::EntityId m_FileInDefaultDestEntityId;

          Svc::Ccsds::Cfdp::Class m_FileInDefaultClass;

          Svc::Ccsds::Cfdp::Keep m_FileInDefaultKeep;

          U8 m_FileInDefaultPriority;

          Svc::Ccsds::Cfdp::ChannelArrayParams m_ChannelConfig;

        private:

          // ----------------------------------------------------------------------
          // Mutexes
          // ----------------------------------------------------------------------

          Os::Mutex m_guardedPortMutex;

          Os::Mutex m_paramLock;

      };

    }

  }

}

#endif