mi32/micache.h

Go to the documentation of this file.

#ifndef  INC_MI32_MICACHE_H
#define  INC_MI32_MICACHE_H

#ifndef  INC_MI32_CONTAINERITEMSYNC_H
#include <mi32/containeritemsync.h>
#endif

#ifdef MISYSTEMDLL
   #define CLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class MICACHEPRIV;
class MICACHEITEMPRIV;
class MICACHEIO;
#endif // GENERATING_DOXYGEN_OUTPUT


class CLASSEXPORT MICACHE {
   public:

      enum SELECTFLAGS {
         SELECTFLAG_None =       0x0000,
         SELECTFLAG_NewItem =    0x0001,     
         SELECTFLAG_NoRead =     0x0002      
         };

      class CLASSEXPORT ITEMINFO {
         public:
            ITEMINFO (
               );

            ~ITEMINFO (
               );

            INT32 GetItemID (
               ) const;

            const void* GetMemPtr (
               ) const;

            void* GetMemPtr (
               );

            void* GetUserDataPtr (
               );

            void SetMemPtr (
               void *memptr,
               INT32 size
               );

            void SetModified (
               );

            void SetUserDataPtr (
               void* UserDataPtr
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            MICACHEITEMPRIV* m_pPriv;
            MITHREAD::CONTAINERITEMSYNC::OBJECT m_ItemSync;
            
            void ReleaseLock ();

            ITEMINFO (const ITEMINFO&);
            ITEMINFO& operator= (const ITEMINFO&);

            friend class MICACHEPRIV;
            friend class MICACHE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      MICACHE ();

      ~MICACHE ();

      ERRVALUE Create (
         INT32 NumCache,                     
         INT32 ItemSize,                     
         MICACHEIO& ioref,
         INT32 NumHash = 0,                  
         bool bSynchronizeAccess = false     
         );

      ERRVALUE Create (
         INT32 NumCache,                  
         MICACHEIO& ioref,
         INT32 NumHash = 0,                  
         bool bSynchronizeAccess = false     
         );

      ERRVALUE Flush (
         );

      ERRVALUE FlushItem (
         INT32 ItemID
         );

      void Free (
         );

      bool IsCreated (
         ) const;

      ERRVALUE Read (
         INT32 ItemID,                    
         INT32 NumBytes,                  
         void *buffer,                    
         void* UserDataPtr = 0            
         );

      ERRVALUE Read (
         INT32 ItemID,                    
         INT32 Offset,                    
         INT32 NumBytes,                  
         void *buffer,                    
         void* UserDataPtr = 0            
         );

      ERRVALUE Resize (
         INT32 NumCache,
         INT32 NumHash = 0
         );

      ERRVALUE Select (
         INT32 ItemID,
         ITEMINFO& iteminfo,
         SELECTFLAGS flags = SELECTFLAG_None,
         void* UserDataPtr = 0            
         );

      ERRVALUE Write (
         INT32 ItemID,                    
         INT32 NumBytes,                  
         const void *buffer,              
         void* UserDataPtr = 0            
         );

      ERRVALUE Write (
         INT32 ItemID,                    
         INT32 Offset,                    
         INT32 NumBytes,                  
         const void *buffer,              
         void* UserDataPtr = 0            
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MICACHEPRIV *m_priv;

      MICACHE (const MICACHE&);
      MICACHE& operator= (const MICACHE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class MICACHEIO {
   protected:
      virtual ERRVALUE CacheLoad (
         MICACHE::ITEMINFO& iteminfo
         ) = 0;

      virtual ERRVALUE CacheSave (
         MICACHE::ITEMINFO& iteminfo
         ) = 0;
   friend class MICACHEPRIV;
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MICACHE::SELECTFLAGS)
#endif

#undef CLASSEXPORT

#endif   // INC_MI32_MICACHE_H

---