flexray_framevector.h

Go to the documentation of this file.

 
#pragma once
 
#include "flexray_frame.h"
#include <adtf_utils.h>
 
namespace adtf
{
 
namespace devicetb
{
 
namespace sdk
{
 
namespace flexray
{
 
namespace axle
{
 
class cFlexRayFrameVector
{
    uint8_t* m_pData;                
    int    m_nDataSize;            
    int    m_nDataSizeAllocated;   
    bool   m_bDataRef;             
 
public:
    class cIterator
    {
        typedef const tFlexRayData* tReference;
 
        const cFlexRayFrameVector*  m_pDataVector;
        int                         m_nCurrentOffset;
 
    public:
        cIterator(const cFlexRayFrameVector* pDataVector)
        {
            m_pDataVector = pDataVector;
            m_nCurrentOffset = 0;
        }
 
        tReference operator* () const
        {
            return (tReference) ((uint8_t*)(m_pDataVector->GetDataPtr()) + m_nCurrentOffset);
        }
 
        void operator++()
        {
            if (IsValid())
            {
                tReference pFRData = (tReference) ((uint8_t*)(m_pDataVector->GetDataPtr()) + m_nCurrentOffset);
                m_nCurrentOffset += pFRData->nSize;
            }
        }
 
        bool IsValid() const
        {
            tReference pFRData = (tReference) ((uint8_t*)(m_pDataVector->GetDataPtr()) + m_nCurrentOffset);
            return (m_nCurrentOffset < m_pDataVector->GetSize()  
                &&  pFRData->nSize != 0  &&  pFRData->nTag != tFlexRayData::FR_TAG_INVALID);
        }
    };
 
public:
    cFlexRayFrameVector()    
    {
        m_pData = NULL;
        Init();
    }
 
    cFlexRayFrameVector(const void* pData, int nDataSize)
    {
        m_pData = (uint8_t*) pData;
        m_nDataSizeAllocated = 0;
        m_nDataSize = nDataSize;
        m_bDataRef = true;
    }
 
    ~cFlexRayFrameVector()    
    {
        if (m_pData != NULL  &&  !m_bDataRef)
        {
            delete [] m_pData;
        }
    }
 
    void Init()
    {
        m_bDataRef = false;
        m_nDataSize = 0;
        m_nDataSizeAllocated = 0;
    }
 
    const void* GetDataPtr() const
    {
        return m_pData;
    }
 
    int GetSize() const
    {
        return m_nDataSize;
    }
 
    cIterator GetFirst() const
    {
        return cIterator(this);
    }
 
    tResult Append(const tFlexRayData* pFRData)
    {
        RETURN_IF_POINTER_NULL(pFRData);
        tFlexRayData* pNewData = NULL;
        // if needed, enlarge the data area and return the pointer to the end
        // of the last set data area
        RETURN_IF_FAILED(Append(pFRData->nSize, &pNewData));
        // copy the new data into the data area
        adtf::util::cMemoryBlock::MemCopy(pNewData, pFRData, pFRData->nSize);
        RETURN_NOERROR;
    }
 
    tResult Append(int nSize, tFlexRayData** pFRData)
    {
        if (m_bDataRef)
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
 
        RETURN_IF_POINTER_NULL(pFRData);
 
        // If memory block is too small, it will be enlarged
        if (m_nDataSize + nSize > m_nDataSizeAllocated)
        {
            int nNewDataSizeAllocated = m_nDataSizeAllocated + nSize + 4096;
            uint8_t* pNewData = new uint8_t[nNewDataSizeAllocated];
            adtf::util::cMemoryBlock::MemCopy(pNewData, m_pData, m_nDataSize);
            delete [] m_pData;
            m_pData = pNewData;
            m_nDataSizeAllocated = nNewDataSizeAllocated;
        }
 
        *pFRData = (tFlexRayData*) (m_pData + m_nDataSize);
        m_nDataSize += nSize;
        RETURN_NOERROR;
    }
};
 
} //namespace axle
using cFlexRayFrameVector = axle::cFlexRayFrameVector;    
} //namespace flexray
} //namespace sdk
} // namespace devicetb
} // namespace adtf