GmCharRingBufferStorage.hpp

#ifndef GM_CHAR_RING_BUFFER_STORAGE_HPP_
#define GM_CHAR_RING_BUFFER_STORAGE_HPP_
 
#include <GmCharRingBuffer.hpp>
#include <GmStorage.hpp>
 
namespace Geometrics
{
 
   class GmRingBufferFileStorage : public GmStorage
   {
   public:
       GmRingBufferFileStorage      (void       *buffer,
                                     uint64_t    bufferSize);
       int          Open            (int        *fileIndex);
       virtual      int  Close      (int         iFileIndex);
       int          Erase           (int         fileIndex);
       int64_t      FileSize        (int         fileIndex);
 
 
       GmRingBufferFileStorage () = delete; // No default constructor.
 
    //  Without this variable defined in a cpp file, the CCS linker won't find a place
    //     for the vtable for this class.  Hacky.  Maybe find some real functionality
    //     in here.
    virtual int   WriteData   (const char*     pcData,
                               unsigned int    iDataSize,
                               UInt32          ui32Topic);
    int           OpenRead    (const int       fileIndex);
    int           Read        (void           *dest,
                               int64_t         count);
 
    int           FileSize    (const int       fileName,
                               int64_t        &fileSize);
    int GetFileInfoIndex (const int fileName);
 
    /***********************************************************************************/
    /* Some storages need to treat some groups of writes as single transactions.  For  */
    /*    example, file storages may decide to roll over to a new physical file after  */
    /*    some number of writes.  In the case of array writes, when the header gets    */
    /*    written and then a set of records gets written, the file storage must        */
    /*    put the array header and all of the individual records all in the same file, */
    /*    and roll over only after the end.  The default behavior for storages         */
    /*    is a NOP.  EnterTransaction and LeaveTransaction handle this feature.        */
    /***********************************************************************************/
    virtual int   EnterTransaction ();
    virtual int   LeaveTransaction ();
    virtual int   RollAndSynchFile ();
 
    //virtual int   IsFileStorage    () { return FALSE; };
    virtual int   IsDataStorage    () { return TRUE; };
    int           CheckToFlush     ();
    int           WriteHeader      ();
    int           SelectSurveyEx   (const char     *strSurveyId);
    int           SelectAcqJsonEx  (const char *strSurveyId,
                                    const char *strAcquisitionId);
    int           SelectAcqEx      (const char *strSurveyId,
                                    const char *strAcquisitionId);
    int64_t       StartOf          (const int   fileName);
    int64_t       EndOf            (const int   fileName);
 
 
    virtual int   GetLastError () { return -1; };
 
    ~GmRingBufferFileStorage ();
 
   public:
    int Initialize ();
    int SetEmpty   ();
 
 
   public:
     class GmRingBufferFileInfo
     {
     public:
         int      Initialize();
         int64_t  mSize;
         int64_t  mStart;
         int64_t  mNumber;
         bool     mReadOnly;
         bool     mIsOpen;
     };
 
#define NUM_BUFFER_FILE_INFOS (10)
     GmRingBufferFileInfo  mFiles[NUM_BUFFER_FILE_INFOS];
     int                   mLastFileInfo;
 
 
 
 
     GmCharRingBuffer      mBuffer;
     int                   mLastFileIndex;
     int                   mWritesCounted;
 
     int                   mApproximateBytesPerFile;
     Bool                  m_bInTransaction;
     char                  m_szCurrentActiveSurveyId[MAX_SURVEY_ID_LENGTH+1],
                           m_szCurrentActiveAcquisitionId[MAX_ACQUISITION_ID_LENGTH+1];
 
 
 
   };
 
}
#endif /* GM_CHAR_RING_BUFFER_STORAGE_HPP_ */