sf_memory.h

   1 #pragma once
   2 namespace sf {
   3 // policy class
   4 struct heap_memory_free_policy
   5 {
   6 template< typename T >
   7 void operator()( const T* AMemory ) const
   8 {
   9 if( NULL != AMemory )
  10 ::HeapFree( ::GetProcessHeap(), 0, AMemory );
  11 }
  12 };
  13 // policy class
  14 struct local_memory_free_policy
  15 {
  16 template< typename T >
  17 void operator()( const T* AMemory ) const
  18 {
  19 if( NULL != AMemory )
  20 ::LocalFree( AMemory );
  21 }
  22 };
  23 // policy class
  24 struct co_task_memory_free_policy
  25 {
  26 template< typename T >
  27 void operator()( const T* AMemory ) const
  28 {
  29 if( NULL != AMemory )
  30 ::CoTaskMemFree( AMemory );
  31 }
  32 };
  33 // base guard class
  34 template< typename T,class TFreePolicy >
  35 class base_memory
  36 {
  37 private:
  38 T *FMemory;
  39
  40 public:
  41 base_memory( T* AMemory = NULL )
  42 : FMemory( AMemory ) {}
  43
  44 virtual ~base_memory( void )
  45 { reset(); }
  46
  47 T* release( void )
  48 {
  49 T *tmp = FMemory;
  50 FMemory = NULL;
  51 return tmp;
  52 }
  53
  54 void reset( T* AMemory = NULL )
  55 {
  56 if( AMemory != FMemory )
  57 {
  58 if( NULL != FMemory )
  59 TFreePolicy( FMemory );
  60
  61 FMemory = AMemory;
  62 }
  63 }
  64
  65 T* get( void )
  66 { return FMemory; }
  67
  68 T* operator ->(void)
  69 {
  70   return FMemory;
  71 }
  72
  73 T** operator&( void )
  74 { return &FMemory; }
  75
  76 };
  77 template< typename T >
  78 class heap_memory : public base_memory< T,
  79 heap_memory_free_policy >
  80 {
  81 public:
  82 heap_memory( T* AMemory = NULL )
  83 : base_memory< T, heap_memory_free_policy >( AMemory )
  84 { }
  85 };
  86 template< typename T >
  87 class local_memory : public base_memory< T,
  88 local_memory_free_policy >
  89 {
  90 public:
  91 local_memory( T* AMemory = NULL )
  92 : base_memory< T, local_memory_free_policy >( AMemory )
  93 { }
  94 };
  95 template< typename T >
  96 class co_task_memory : public base_memory< T, co_task_memory_free_policy >
  97 {
  98 public:
  99 co_task_memory( T* AMemory = NULL )
 100 : base_memory< T, co_task_memory_free_policy >( AMemory )
 101 { }
 102 };
 103
 104 struct handle_deleter {
 105   typedef HANDLE pointer;
 106   void operator ()(HANDLE handle) {
 107       if (handle != INVALID_HANDLE_VALUE) {
 108           CloseHandle(handle);
 109       }
 110   }
 111 };
 112
 113 typedef std::unique_ptr<HANDLE,handle_deleter> handle_holder;
 114
 115 };