GmArrayRingBuffer.hpp

 
#ifndef GMARRAYRINGBUFFER_HPP_
#define GMARRAYRINGBUFFER_HPP_
 
/*
 * GmArrayingBuffer.hpp
 *
 */
 
#include <array>
 
namespace Geometrics
{
   // Initially, this is FIFO only.
   // This class has no concurrency control.  That must occur
   //   in the clients of this class.
   // Would be nice to add priority, so that for purposes
   //    such as task switching,
   //    we could put higher-priority items in the buffer.
   template<typename T, int C>
   class GmArrayRingBuffer : private std::array<T, C>
   {
   public:
 
      GmArrayRingBuffer  ( Bool             bOkToOverrun,
                           Bool             bNotices);
      virtual ~GmArrayRingBuffer () {};
     int  WriteRecord       (T          *pcSource);
     int  ReadRecord         (T          *pcDestination);
     int  NoticeRecord      (int    *piDestination);
     int  ForgetNextRecord  ();
     int  CheckToWrite      ();
     void SetEmpty          ();
     Bool IsEmpty           ();
     Bool HasData           ();
     Bool HasUnnoticedData  ();
     int  ReserveRecord     (int *pIndex);
     T&   GetBuffer          (int     iBufferIndex);
     int  CopyAndCommitData   (T   *pcSource,
                               int         index);
     int  CommitData (int index);
     int  Size();
     int  MaxSize();
 
   protected:
     int  InternalWriteRecord  (T   *pcSource);
     int                m_iLastBufferRead,
                        m_iLastBufferNoticed,
                        m_iLastBufferWritten;
     
     // To manage overruns.  See notes in CPP
     Bool               m_bNextWriteWouldOverrun,
       m_bNextWriteWouldOverrunNotice,
       m_bOkToOverrun,
       m_bNotices;
     
   };
}
 
/****************/
#ifndef _GEO_APPDEFS_HPP
#include <GeoAppDefs.hpp>
#endif
 
#include "string.h"
#ifdef linux
#include <stdint.h>
#endif
 
#ifdef acs
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Memory.h>
#endif
#include "geotypes.hpp"
 
#include "GmRingBuffer.hpp"
 
#include "GmArrayRingBuffer.hpp"
 
using namespace Geometrics;
 
//#define DEBUGGING_COMPILE_ISSUES
#ifdef DEBUGGING_COMPILE_ISSUES
GmArrayRingBuffer<uint8_t,20> theArray(true,true);
uint8_t aTestItem;
#endif
 
/******************************************************************************************************************/
/* Notes:
 *   The read and write pointers can be the same in two cases - if the read pointer has caught up with the
 *   write pointer, in which case the FIFO is empty; or if the write pointer has caught up with the read pointer,
 *   in which case the buffer is full.
 */
/******************************************************************************************************************/
template<typename T, int C>
GmArrayRingBuffer<T,C>::GmArrayRingBuffer ( Bool             bOkToOverrun,
                                            Bool             bNotices)
               : std::array<T,C>(),
                 m_bOkToOverrun            (bOkToOverrun),
                 m_bNotices                (bNotices)
{
/*   // If we fail to allocate the space, the buffer will be NULL, and
   //    we will check for it.
   if (uiBufferSize == (iMaxItems * iItemSize))
      m_Buffer = puiBuffer;
   else
      m_Buffer = NULL;
      */
   SetEmpty ();
#ifdef DEBUGGING_COMPILE_ISSUES
   GetBuffer(0);
   IsEmpty ();
   MaxSize();
   Size();
   ReadRecord (&aTestItem);
   ForgetNextRecord ();
   WriteRecord(&aTestItem);
#endif
}
 
template<typename T, int C>
void GmArrayRingBuffer<T,C>::SetEmpty ()
{
   // Just reset the counters and flags.
   m_iLastBufferRead                = -1;
   m_iLastBufferWritten             = -1;
   m_iLastBufferNoticed             = -1;
   m_bNextWriteWouldOverrun         = FALSE;
   m_bNextWriteWouldOverrunNotice   = FALSE;
}
 
template<typename T, int C>
T& GmArrayRingBuffer<T,C>::GetBuffer (int iBufferIndex)
{
   if ((iBufferIndex < 0) ||
       (iBufferIndex >= this->size()))
      return this->at(0); //nullptr;
  // auto it = this->begin();
  // return it.  [iBufferIndex];
   //return this->begin()[iBufferIndex];
   return this->at(iBufferIndex);
}
 
template<typename T, int C>
Bool GmArrayRingBuffer<T,C>::IsEmpty ()
{
   return ((m_iLastBufferRead == m_iLastBufferWritten)&&
            !m_bNextWriteWouldOverrun);
}
 
 
template<typename T, int C>
int  GmArrayRingBuffer<T,C>::MaxSize()
{
  return this->size();
}
 
template<typename T, int C>
int  GmArrayRingBuffer<T,C>::Size()
{
  if (m_iLastBufferRead < m_iLastBufferWritten)
  {
    return (m_iLastBufferWritten - m_iLastBufferRead);
  }
  else if (m_iLastBufferWritten < m_iLastBufferRead)
  {
    return (this->size() - m_iLastBufferRead + m_iLastBufferWritten);
  }
  else if (m_iLastBufferWritten == -1)
  {
    return 0;
  }
  else
  {
    return MaxSize();
  }
}
 
template<typename T, int C>
Bool GmArrayRingBuffer<T,C>::HasData ()
{
   return (!IsEmpty ());
}
 
template<typename T, int C>
Bool GmArrayRingBuffer<T,C>::HasUnnoticedData ()
{
   return (HasData () && (this->m_iLastBufferNoticed != m_iLastBufferRead));
}
 
// ===============================================================
// Non-destructive peek.  This allows a consumer (e.g. another buffer
//   that c<T,C>onsolidates the contents of several buffers) to keep a
//   reference lock on an item in this buffer.
// TODO RHC not perfectly happy with this implementation.  it's
//   pretty single-purpose.
// ===============================================================
template<typename T, int C>
int GmArrayRingBuffer<T,C>::NoticeRecord (int     *piDestination)
{
   int                iNotice;
 
   if (m_Buffer == NULL)
      return GM_RING_BUFFER_FAILURE;
 
   if (IsEmpty ())
      return GM_RING_BUFFER_EMPTY;
 
   if (!HasUnnoticedData ())
   {
      return GM_RING_BUFFER_NO_UNNOTICED;
   }
 
   // Prep to read the buffer.  Don't yet mark it as having been read.
   iNotice = m_iLastBufferNoticed + 1;
 
   if (iNotice == m_iMaxItems)
      iNotice = 0;
   *piDestination = iNotice;
 
   // A notice always unsets the overrun flag.
   //  TODO RHC I don't think this is correct.  Can allow an overrun, if the point
   /*   is to reserve a record for view, and the system writes again   */
   m_bNextWriteWouldOverrunNotice = FALSE;
 
   // We are done with this buffer.  Advance the counter.
   m_iLastBufferNoticed = iNotice;
 
   return GM_RING_BUFFER_OK;
}
 
// ===============================================================
// Destructive read - fetch the data and advance the read pointer.
//    The record is no longer available for reading.
// ===============================================================
template<typename T, int C>
int GmArrayRingBuffer<T,C>::ReadRecord (T*   pcDestination)
{
   int                iReadBuffer;
  // UInt8             *wrkBuffer;
 
   if (IsEmpty ())
      return GM_RING_BUFFER_EMPTY;
 
   // Prep to read the buffer.  Don't yet mark it as having been read.
   iReadBuffer = m_iLastBufferRead + 1;
 
   if (iReadBuffer == this->size())
     iReadBuffer = 0;
 
   if (pcDestination != nullptr)
   {
       *pcDestination = GetBuffer (iReadBuffer);
   }
 
   // A data read always unsets the overrun flag.
   m_bNextWriteWouldOverrun = FALSE;
 
   // We are done with this buffer.  Advance the counter.
   if (iReadBuffer == m_iLastBufferWritten)
   {
      m_iLastBufferWritten = -1;
      m_iLastBufferRead    = -1;
   }
   else
   {
      m_iLastBufferRead = iReadBuffer;
   }
 
   if (pcDestination == nullptr)
      return GM_RING_BUFFER_NULL_DESTINATION;
   else
      return GM_RING_BUFFER_OK;
}
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::ForgetNextRecord ()
{
 
    int iTest = ReadRecord (NULL);
   switch (iTest)
   {
      case GM_RING_BUFFER_NULL_DESTINATION:
      return GM_RING_BUFFER_OK;
 
      // Should never return OK.
      case GM_RING_BUFFER_OK:
      return GM_RING_BUFFER_FAILURE;
 
      default:
      return iTest;
   }
}
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::WriteRecord (T*   pcSource)
{
   #ifndef NDEBUG
   int iTest;
   iTest = CheckToWrite ( iSize);
   if (iTest == GM_RING_BUFFER_OK)
   #endif
      return InternalWriteRecord (pcSource);
   #ifndef NDEBUG
   else
      return iTest;
   #endif
}
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::CheckToWrite ()
{
   return GM_RING_BUFFER_OK;
}
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::ReserveRecord (int *pIndex)
{
   int                iWriteBuffer;
  // UInt8             *wrkBuffer;
   int                iReturn = GM_RING_BUFFER_OK;
 
   // If the write pointer caught up with the read pointer on the
   //   last write, then this write would overwrite existing,
   //   unread data.
   if (m_bNextWriteWouldOverrun)
   {
      if (m_bOkToOverrun)
      {
         SetEmpty ();
         m_bNextWriteWouldOverrun = FALSE;
 
         // Recurse.  With empty system, should write just fine.
         iReturn = ReserveRecord (pIndex);
 
         // But we will return the fact that we did overwrite...
         if (iReturn == GM_RING_BUFFER_OK)
            return GM_RING_BUFFER_OVERRUN_OVERWROTE;
         else
            return iReturn;
      }
      // ... but if we've said it's not OK to overrun the buffer, then we won't
      //    write the data, and will simply abort the write.
      else
      {
         return GM_RING_BUFFER_OVERRUN_NO_WRITE;
      }
   }
 
   // TODO RHC not so sure about this.
   if (m_bNextWriteWouldOverrunNotice)
   {
      m_iLastBufferNoticed++;
      if (m_iLastBufferNoticed == this->size())
         m_iLastBufferNoticed = 0;
   }
 
   iWriteBuffer = m_iLastBufferWritten + 1;
   if (iWriteBuffer == this->size())
      iWriteBuffer      = 0;
 
   // ======= Have we caught up with the read pointer? ======
   if (iWriteBuffer == m_iLastBufferRead)
   {
      m_bNextWriteWouldOverrun = TRUE;
   }
   else
   {
      if (iWriteBuffer == m_iLastBufferNoticed)
      {
         m_bNextWriteWouldOverrunNotice = TRUE;
      }
   }
   *pIndex = iWriteBuffer;
   return GM_RING_BUFFER_OK;
}
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::CommitData (int index)
{
  m_iLastBufferWritten = index;
  return GM_RING_BUFFER_OK;
}
 
 
template<typename T, int C>
int  GmArrayRingBuffer<T,C>::CopyAndCommitData (T    *pcSource,
                     int         index)
{
 // T wrkBuffer;
  // Finally, write the data and update the counters.
 // wrkBuffer = GetBuffer (index);
  GetBuffer(index) = *pcSource;
  //*pcSource = GetBuffer(index);asdf
  //wrkBuffer;
 
  // We are done with this buffer.  Advance the counter.
  m_iLastBufferWritten = index;
 
  return GM_RING_BUFFER_OK;
}
 
 
template<typename T, int C>
int GmArrayRingBuffer<T,C>::InternalWriteRecord (T*   pcSource)
{
   int                iWriteBuffer;
 
 
   int iReturn = ReserveRecord (&iWriteBuffer);
 
   if ((iReturn == GM_RING_BUFFER_OK) ||
      (iReturn == GM_RING_BUFFER_OVERRUN_OVERWROTE))
   {
     int iWriteTest = CopyAndCommitData (pcSource,iWriteBuffer);
     if (iWriteTest != GM_RING_BUFFER_OK)
       return iWriteTest;
   }
   return iReturn;
 }
 
#endif /* GMRINGBUFFER_HPP_ */