GmMemoryStorage.hpp

#ifndef GM_MEMORY_STORAGE_HPP_
#define GM_MEMORY_STORAGE_HPP_
 
//#if GEO_MEMORY_STORAGE == GEO_TRUE
 
typedef unsigned long DWORD;
 
#include <geotypes.hpp>
#include <GmStorage.hpp>
 
namespace Geometrics
{
    class GmMemoryStorage : public GmStorage
    {
        public:
 
          GmMemoryStorage (void *buffer, const uint32_t bufferLength);
        //  virtual int   Open                 (const char*     zName,
        //                                            const char*   szReadWrite) { return 0; };
            virtual int   Close                (int           iFileIndex); // { return 0;};
 
         //  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);
 
         /***********************************************************************************/
         /* 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 () { return GM_STORAGE_OK; };
         virtual int   LeaveTransaction () { return GM_STORAGE_OK; };
         virtual int   RollAndSynchFile () { return GM_STORAGE_OK; };
 
         //virtual int   IsFileStorage    () { return FALSE; };
         virtual int   IsDataStorage    () { return FALSE; };
 
 
 
         virtual int   GetLastError () { return -1; };
 
         virtual ~GmMemoryStorage ();
 
         /*******************************************************************************************/
         /* IsOpen is declared here, and also defined, in order to provide a model of the function  */
         /*    throughout the class tree derived from GmStorage.  BUT, we don't want to rely on this */
         /*    implementation, so it will break.  If you develop code that requires IsOpen(), then  */
         /*    you must develop for the correction semantics for that class.                        */
         /*******************************************************************************************/
         virtual bool  IsOpen () { return m_bIsOpen; /* m_bIsOpen;*/ };
 
        protected:
         bool   m_bIsOpen;
 
         void   Reset ();
 
         uint32_t GetWriteCursorLocation() { return mBufferWriteCursor; }
 
        private:
         void     *mBuffer;
         uint32_t  mBufferWriteCursor;
         uint32_t  mBufferReadCursor;
         uint32_t  mBufferSize;
    };
}
#endif
 
//#endif