ActiveTest.hpp

Go to the documentation of this file.

// ======================================================================
// \title  ActiveTest.hpp
// \author tiffany
// \brief  hpp file for ActiveTest component implementation class
// ======================================================================
 
#ifndef ActiveTest_HPP
#define ActiveTest_HPP
 
#include "FppTest/component/active/ActiveTestComponentAc.hpp"
#include "FppTest/component/types/FormalParamTypes.hpp"
 
 
class ActiveTest :
  public ActiveTestComponentBase
{
 
  public:
 
    // ----------------------------------------------------------------------
    // Component construction and destruction
    // ----------------------------------------------------------------------
 
    ActiveTest(
        const char* const compName 
    );
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE msgSize, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    ~ActiveTest();
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Handler implementations for user-defined typed input ports
    // ----------------------------------------------------------------------
 
    void arrayArgsAsync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamArray& a, 
        FormalParamArray& aRef 
    );
 
    void arrayArgsGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamArray& a, 
        FormalParamArray& aRef 
    );
 
    void arrayArgsSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamArray& a, 
        FormalParamArray& aRef 
    );
 
    FormalParamArray arrayReturnGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamArray& a, 
        FormalParamArray& aRef 
    );
 
    FormalParamArray arrayReturnSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamArray& a, 
        FormalParamArray& aRef 
    );
 
    void cmdOut_handler(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer& args 
    );
 
    void enumArgsAsync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamEnum& en, 
        FormalParamEnum& enRef 
    );
 
    void enumArgsGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamEnum& en, 
        FormalParamEnum& enRef 
    );
 
    void enumArgsSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamEnum& en, 
        FormalParamEnum& enRef 
    );
 
    FormalParamEnum enumReturnGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamEnum& en, 
        FormalParamEnum& enRef 
    );
 
    FormalParamEnum enumReturnSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamEnum& en, 
        FormalParamEnum& enRef 
    );
 
    void noArgsAsync_handler(
        NATIVE_INT_TYPE portNum 
    );
 
    void noArgsGuarded_handler(
        NATIVE_INT_TYPE portNum 
    );
 
    bool noArgsReturnGuarded_handler(
        NATIVE_INT_TYPE portNum 
    );
 
    bool noArgsReturnSync_handler(
        NATIVE_INT_TYPE portNum 
    );
 
    void noArgsSync_handler(
        NATIVE_INT_TYPE portNum 
    );
 
    void primitiveArgsAsync_handler(
        NATIVE_INT_TYPE portNum, 
        U32 u32,
        U32& u32Ref,
        F32 f32,
        F32& f32Ref,
        bool b,
        bool& bRef
    );
 
    void primitiveArgsGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        U32 u32,
        U32& u32Ref,
        F32 f32,
        F32& f32Ref,
        bool b,
        bool& bRef
    );
 
    void primitiveArgsSync_handler(
        NATIVE_INT_TYPE portNum, 
        U32 u32,
        U32& u32Ref,
        F32 f32,
        F32& f32Ref,
        bool b,
        bool& bRef
    );
 
    U32 primitiveReturnGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        U32 u32,
        U32& u32Ref,
        F32 f32,
        F32& f32Ref,
        bool b,
        bool& bRef
    );
 
    U32 primitiveReturnSync_handler(
        NATIVE_INT_TYPE portNum, 
        U32 u32,
        U32& u32Ref,
        F32 f32,
        F32& f32Ref,
        bool b,
        bool& bRef
    );
 
    void stringArgsAsync_handler(
        NATIVE_INT_TYPE portNum, 
        const StringArgsPortStrings::StringSize80& str80, 
        StringArgsPortStrings::StringSize80& str80Ref,
        const StringArgsPortStrings::StringSize100& str100, 
        StringArgsPortStrings::StringSize100& str100Ref
    );
 
    void stringArgsGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const StringArgsPortStrings::StringSize80& str80, 
        StringArgsPortStrings::StringSize80& str80Ref,
        const StringArgsPortStrings::StringSize100& str100, 
        StringArgsPortStrings::StringSize100& str100Ref
    );
 
    void stringArgsSync_handler(
        NATIVE_INT_TYPE portNum, 
        const StringArgsPortStrings::StringSize80& str80, 
        StringArgsPortStrings::StringSize80& str80Ref,
        const StringArgsPortStrings::StringSize100& str100, 
        StringArgsPortStrings::StringSize100& str100Ref
    );
 
    void structArgsAsync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamStruct& s, 
        FormalParamStruct& sRef 
    );
 
    void structArgsGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamStruct& s, 
        FormalParamStruct& sRef 
    );
 
    void structArgsSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamStruct& s, 
        FormalParamStruct& sRef 
    );
 
    FormalParamStruct structReturnGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamStruct& s, 
        FormalParamStruct& sRef 
    );
 
    FormalParamStruct structReturnSync_handler(
        NATIVE_INT_TYPE portNum, 
        const FormalParamStruct& s, 
        FormalParamStruct& sRef 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Handler implementations for user-defined serial input ports
    // ----------------------------------------------------------------------
 
    void serialAsync_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
    void serialAsyncAssert_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
    void serialAsyncBlockPriority_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
    void serialAsyncDropPriority_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
    void serialGuarded_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
    void serialSync_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::SerializeBufferBase& buffer 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Handler implementations for commands
    // ----------------------------------------------------------------------
 
    void CMD_NO_ARGS_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    void CMD_PRIMITIVE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        U32 u32_1, 
        U32 u32_2, 
        F32 f32_1, 
        F32 f32_2, 
        bool b1, 
        bool b2 
    );
 
    void CMD_STRINGS_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& str1, 
        const Fw::CmdStringArg& str2 
    );
 
    void CMD_ENUM_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamEnum en 
    );
 
    void CMD_ARRAY_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamArray arr 
    );
 
    void CMD_STRUCT_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamStruct str 
    );
 
    void CMD_ASYNC_NO_ARGS_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    void CMD_ASYNC_PRIMITIVE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        U32 u32_1, 
        U32 u32_2, 
        F32 f32_1, 
        F32 f32_2, 
        bool b1, 
        bool b2 
    );
 
    void CMD_ASYNC_STRINGS_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& str1, 
        const Fw::CmdStringArg& str2 
    );
 
    void CMD_ASYNC_ENUM_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamEnum en 
    );
 
    void CMD_ASYNC_ARRAY_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamArray arr 
    );
 
    void CMD_ASYNC_STRUCT_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        FormalParamStruct str 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Handler implementations for user-defined internal interfaces
    // ----------------------------------------------------------------------
 
    void internalArray_internalInterfaceHandler(
        const FormalParamArray& arr 
    );
 
    void internalEnum_internalInterfaceHandler(
        const FormalParamEnum& en 
    );
 
    void internalNoArgs_internalInterfaceHandler();
 
    void internalPrimitive_internalInterfaceHandler(
        U32 u32_1, 
        U32 u32_2, 
        F32 f32_1, 
        F32 f32_2, 
        bool b1, 
        bool b2 
    );
 
    void internalString_internalInterfaceHandler(
        const Fw::InternalInterfaceString& str1, 
        const Fw::InternalInterfaceString& str2 
    );
 
    void internalStruct_internalInterfaceHandler(
        const FormalParamStruct& str 
    );
 
  public:
 
    Fw::SerializeStatus serializeStatus;
 
    // Command test values
    FppTest::Types::PrimitiveParams primitiveCmd;
    FppTest::Types::CmdStringParams stringCmd;
    FppTest::Types::EnumParam enumCmd;
    FppTest::Types::ArrayParam arrayCmd;
    FppTest::Types::StructParam structCmd;
 
    // Internal interface test values
    FppTest::Types::PrimitiveParams primitiveInterface;
    FppTest::Types::InternalInterfaceStringParams stringInterface;
    FppTest::Types::EnumParam enumInterface;
    FppTest::Types::ArrayParam arrayInterface;
    FppTest::Types::StructParam structInterface;
 
};
class ActiveTest : {…};
 
 
#endif