DpContainer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  DpContainer.hpp
// \author bocchino
// \brief  hpp file for DpContainer
// ======================================================================
 
#ifndef Fw_DpContainer_HPP
#define Fw_DpContainer_HPP
 
#include "Fw/Buffer/Buffer.hpp"
#include "Fw/Dp/DpStateEnumAc.hpp"
#include "Fw/Time/Time.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Utils/Hash/Hash.hpp"
#include "config/FppConstantsAc.hpp"
#include "config/ProcTypeEnumAc.hpp"
 
namespace Fw {
 
class DpContainer {
  public:
    // ----------------------------------------------------------------------
    // Constants and Types
    // ----------------------------------------------------------------------
 
    struct Header {
        using UserData = U8[DpCfg::CONTAINER_USER_DATA_SIZE];
        static constexpr FwSizeType PACKET_DESCRIPTOR_OFFSET = 0;
        static constexpr FwSizeType ID_OFFSET = PACKET_DESCRIPTOR_OFFSET + sizeof(FwPacketDescriptorType);
        static constexpr FwDpPriorityType PRIORITY_OFFSET = ID_OFFSET + sizeof(FwDpIdType);
        static constexpr FwSizeType TIME_TAG_OFFSET = PRIORITY_OFFSET + sizeof(FwDpPriorityType);
        static constexpr FwSizeType PROC_TYPES_OFFSET = TIME_TAG_OFFSET + Time::SERIALIZED_SIZE;
        static constexpr FwSizeType USER_DATA_OFFSET = PROC_TYPES_OFFSET + sizeof(DpCfg::ProcType::SerialType);
        static constexpr FwSizeType DP_STATE_OFFSET = USER_DATA_OFFSET + DpCfg::CONTAINER_USER_DATA_SIZE;
        static constexpr FwSizeType DATA_SIZE_OFFSET = DP_STATE_OFFSET + DpState::SERIALIZED_SIZE;
        static constexpr FwSizeType SIZE = DATA_SIZE_OFFSET + sizeof(FwSizeStoreType);
    };
 
    static constexpr FwSizeType HEADER_HASH_OFFSET = Header::SIZE;
    static constexpr FwSizeType DATA_OFFSET = HEADER_HASH_OFFSET + HASH_DIGEST_LENGTH;
    static constexpr FwSizeType MIN_PACKET_SIZE = Header::SIZE + 2 * HASH_DIGEST_LENGTH;
 
  public:
    // ----------------------------------------------------------------------
    // Constructors and destructors
    // ----------------------------------------------------------------------
 
    DpContainer(FwDpIdType id,            
                const Fw::Buffer& buffer  
    );
 
    DpContainer();
 
    virtual ~DpContainer() {}
 
  protected:
    // ----------------------------------------------------------------------
    // Protected operators
    // ----------------------------------------------------------------------
 
    DpContainer& operator=(const DpContainer& src) = default;
 
  public:
    // ----------------------------------------------------------------------
    // Public member functions
    // ----------------------------------------------------------------------
 
    FwDpIdType getId() const { return this->m_id; }
 
    FwSizeType getDataSize() const { return this->m_dataSize; }
 
    Fw::Buffer getBuffer() const { return this->m_buffer; }
 
    FwSizeType getPacketSize() const { return getPacketSizeForDataSize(this->m_dataSize); }
 
    FwDpPriorityType getPriority() const { return this->m_priority; }
 
    Fw::Time getTimeTag() const { return this->m_timeTag; }
 
    Fw::DpState getState() const { return this->m_dpState; }
 
    DpCfg::ProcType::SerialType getProcTypes() const { return this->m_procTypes; }
 
    DpState getDpState() const { return this->m_dpState; }
 
    Fw::SerializeStatus deserializeHeader();
 
    void serializeHeader();
 
    void setId(FwDpIdType id  
    ) {
        this->m_id = id;
    }
 
    void setPriority(FwDpPriorityType priority  
    ) {
        this->m_priority = priority;
    }
 
    void setTimeTag(Fw::Time timeTag  
    ) {
        this->m_timeTag = timeTag;
    }
 
    void setProcTypes(DpCfg::ProcType::SerialType procTypes  
    ) {
        this->m_procTypes = procTypes;
    }
 
    void setDpState(DpState dpState  
    ) {
        this->m_dpState = dpState;
    }
 
    void setDataSize(FwSizeType dataSize  
    ) {
        this->m_dataSize = dataSize;
    }
 
    void setBuffer(const Buffer& buffer  
    );
 
    void invalidateBuffer() {
        this->m_buffer = Fw::Buffer();
    }
 
    Utils::HashBuffer getHeaderHash() const;
 
    Utils::HashBuffer computeHeaderHash() const;
 
    void setHeaderHash(const Utils::HashBuffer& hash  
    );
 
    void updateHeaderHash();
 
    Success::T checkHeaderHash(Utils::HashBuffer& storedHash,   
                               Utils::HashBuffer& computedHash  
    ) const;
 
    FwSizeType getDataHashOffset() const {
        // Data hash goes after the header, the header hash, and the data
        return Header::SIZE + HASH_DIGEST_LENGTH + this->m_dataSize;
    }
 
    Utils::HashBuffer getDataHash() const;
 
    Utils::HashBuffer computeDataHash() const;
 
    void setDataHash(Utils::HashBuffer hash  
    );
 
    void updateDataHash();
 
    Success::T checkDataHash(Utils::HashBuffer& storedHash,   
                             Utils::HashBuffer& computedHash  
    ) const;
 
  public:
    // ----------------------------------------------------------------------
    // Public static functions
    // ----------------------------------------------------------------------
 
    static constexpr FwSizeType getPacketSizeForDataSize(FwSizeType dataSize  
    ) {
        return Header::SIZE + dataSize + 2 * HASH_DIGEST_LENGTH;
    }
 
  PRIVATE:
    // ----------------------------------------------------------------------
    // Private member functions
    // ----------------------------------------------------------------------
 
    void initUserDataField();
 
  public:
    // ----------------------------------------------------------------------
    // Public member variables
    // ----------------------------------------------------------------------
 
    Header::UserData m_userData;
 
  PROTECTED:
    // ----------------------------------------------------------------------
    // Protected member variables
    // ----------------------------------------------------------------------
 
    FwDpIdType m_id;
 
    FwDpPriorityType m_priority;
 
    Time m_timeTag;
 
    DpCfg::ProcType::SerialType m_procTypes;
 
    DpState m_dpState;
 
    FwSizeType m_dataSize;
 
    Buffer m_buffer;
 
    Fw::ExternalSerializeBufferWithMemberCopy m_dataBuffer;
};
 
}  // end namespace Fw
 
#endif