canfd_coder_intf.h

Go to the documentation of this file.

 
#pragma once
 
#include "canfd_database_intf.h"
#include "can_types.h"
#include <adtf_streaming3.h>
#include <adtfmediadescription/type_reflection.h>
#include <limits>
 
namespace adtf
{
 
namespace devicetb
{
 
namespace sdk
{
 
namespace canfd
{
 
namespace axle
{
class ICANFDCoder : public adtf::ucom::ant::IObject
{
public:
    ADTF_IID(ICANFDCoder, "canfd_coder.axle.canfd.sdk.devicetb.adtf.iid");
        
    virtual tResult Begin(const adtf::streaming::ISampleBuffer *pData) = 0;
    virtual tResult Begin(const void *pData, int64_t nSize) = 0;
    virtual tResult End() = 0;
 
    virtual tResult SetMessageInfo(tChannelID nChannel, tMessageID nMsgID, bool bExtended, uint16_t nFlags = 0) = 0;
 
    virtual tResult GetMessageInfo(tChannelID* pnChannel, tMessageID* pnMsgID, bool* pbExtended, uint16_t* pnFlags) = 0;
 
    virtual tResult Set(const char* strValueID, const void* pValue) = 0;
 
    virtual tResult Get(const char* strValueID, void* pValue) = 0;
 
    virtual tResult SetSignalValue(tSignalID nSignalID, const tSignalValue* pSignalValue) = 0;
 
    virtual tResult GetSignalValue(tSignalID nSignalID, tSignalValue* pSignalValue) const = 0;
 
    virtual tResult SetRawData(const uint8_t* pData, uint8_t nLength) = 0;
 
    virtual tResult GetRawData(const uint8_t** pData, uint8_t* nLength) const = 0;
 
    virtual tResult GetSignalID(tChannelID nChannel, const char* strValueID, tSignalID* pSignalID) const = 0;
 
    virtual tResult GetDatabase(tChannelID nChannel,
                                  adtf::ucom::ant::iobject_ptr<ICANFDDatabase>& pCANFDDatabase) const = 0;
 
    virtual tResult SetDatabase(tChannelID nChannel, const char* strFileName) = 0;
};
 
} // namespace axle
 
namespace ignition
{
class ICANFDCoder : public adtf::ucom::ant::IObject
{
public:
    ADTF_IID(ICANFDCoder, "canfd_coder.ignition.canfd.sdk.devicetb.adtf.iid");
 
    virtual tResult SetData(const tCANFDData *pData) = 0;
 
    virtual tResult SetData(const adtf::devicetb::sdk::can::tCANData *pData) = 0;
 
    virtual tResult CreateMessage(const tMessageID nMsgId, const tChannelID nChannelId) = 0;
 
    virtual tResult GetMessageData(tCANFDData* pMsgData) = 0;
 
    virtual tResult GetMessageData(adtf::devicetb::sdk::can::tCANData* pMsgData) = 0;
 
    virtual tResult GetMessageId(tMessageID& nMessageId) const = 0;
 
    virtual tResult SetRawSignalValue(tSignalID nSignalId, const tSignalValue& oRawValue) = 0;
 
    virtual tResult SetRawSignalValue(tSignalID nSignalId, const void* pRawValue, uint64_t nSize) = 0;
 
    virtual tResult SetPhysicalSignalValue(tSignalID nSignalId, double nPhysValue) = 0;
 
    virtual tResult GetSignalValue(tSignalID nSignalId, tSignalValue& oRawValue, double& nPhysValue) const = 0;
 
    virtual tResult GetSignalValue(tSignalID nSignalId, void* pRawValue, uint64_t nSize) const = 0;
    
    virtual tResult SetRawData(const void* pData, uint8_t nLength) = 0;
 
    virtual tResult GetDatabase(tChannelID nChannelId,
        adtf::ucom::ant::iobject_ptr<ICANFDDatabase>& pCANFDDatabase) const = 0;
 
    virtual tResult GetAllSignalValues(const ucom::nitro::ifunction<void(tSignalID nSignalId, tSignalValue oRawValue, double nPhysValue)>& fnCallback) const = 0;
 
    virtual tResult GetMultiplexSelectorFieldCode(uint32_t& nSelectorFieldCode) = 0;
 
    virtual tResult SetMultiplexSelectorFieldCode(uint32_t nSelectorFieldCode) = 0;
   
};
 
} // namespace ignition
 
namespace jack
{
    class ICANFDCoder : public ignition::ICANFDCoder
    {
    public:
        using tPduIndex = uint32_t;
 
        ADTF_IID(ICANFDCoder, "canfd_coder.jack.canfd.sdk.devicetb.adtf.iid");
       
        virtual tResult GetContainedPdus(const ucom::nitro::ifunction<void(const tPduInfo* pPduInfo, tPduIndex nPduIndex)>& fnCallback) const = 0;
        
        virtual tResult AddContainedPdu(tPduIndex& nPduIndexContained, tPDUID nPduId, tPduIndex nPduIndexContainer = 0) = 0;
        
        virtual tResult SelectContainedPdu(tPduIndex nPduIndex = 0) = 0;
    };
 
}// namespace jack
 
using ICANFDCoder = jack::ICANFDCoder;    
 
} // namespace canfd
} // namespace sdk
} // namespace devicetb
} // namespace adtf