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();
        this->m_dataBuffer.clear();
        this->m_dataSize = 0;
    }

    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