core/code/system/f_helpers.h

   1 /*
   2     fegdk: FE Game Development Kit
   3     Copyright (C) 2001-2008 Alexey "waker" Yakovenko
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Alexey Yakovenko
  20     waker@users.sourceforge.net
  21 */
  22
  23 #ifndef __F_HELPERS_H
  24 #define __F_HELPERS_H
  25
  26 #include <assert.h>
  27
  28 namespace fe {
  29
  30         class genericCallback
  31         {
  32         public:
  33                 virtual void call (void *data) = 0;
  34         };
  35
  36         // this class is used to store/access objects of different types in one list
  37         class virtualDtorObject
  38         {
  39         public:
  40                 virtual ~virtualDtorObject (void) {}
  41         };
  42
  43         template <class T1, class T2>
  44         inline const T1 checked_cast (T2 src)
  45         {
  46                 assert (src);
  47                 assert (dynamic_cast <T1> (src));
  48                 return static_cast <T1> (src);
  49         }
  50
  51         template <class T> class heapBuffer
  52         {
  53
  54                 // first buffer byte is a refc
  55
  56         private:
  57
  58                 unsigned char*          mpBuffer;
  59
  60         public:
  61
  62                 heapBuffer (int cnt)
  63                 {
  64                         assert (cnt);
  65                         mpBuffer = new unsigned char[cnt * sizeof (T) + 1];
  66                         *mpBuffer = 1;
  67                 }
  68
  69                 heapBuffer (const heapBuffer &b)
  70                 {
  71                         mpBuffer = b.mpBuffer;
  72                         mpBuffer[0]++;
  73                 }
  74
  75                 ~heapBuffer ()
  76                 {
  77                         if (--mpBuffer[0] == 0)
  78                                 delete[] mpBuffer;
  79                 }
  80
  81                 operator T* ()
  82                 {
  83                         return (T*) (mpBuffer + 1);
  84                 }
  85
  86         };
  87
  88         template <class T> class noAddrefReleaseOnSmartRefcPtr : public T
  89         {
  90         private:
  91                 noAddrefReleaseOnSmartRefcPtr (void) : T (NULL) {}
  92                 virtual void addRef () = 0;
  93                 virtual void release () = 0;
  94         };
  95
  96         template <class T> class smartPtr
  97         {
  98
  99         private:
 100
 101                 T*              p;
 102
 103         public:
 104
 105                 smartPtr (void)
 106                 {
 107                         p = NULL;
 108                 }
 109
 110                 smartPtr (T *lp)
 111                 {
 112                         if ( (p = lp) != NULL)
 113                                 p->addRef ();
 114                 }
 115
 116                 smartPtr (const smartPtr<T>& lp)
 117                 {
 118                         if ( (p = lp.p) != NULL)
 119                                 p->addRef ();
 120                 }
 121
 122                 ~smartPtr ()
 123                 {
 124                         if (p)
 125                                 p->release ();
 126                 }
 127
 128                 operator T* () const
 129                 {
 130                         return p;
 131                 }
 132
 133         /*      T& operator* () const
 134                 {
 135                         assert (p != NULL);
 136                         return *p;
 137                 }
 138
 139                 T** operator& ()
 140                 {
 141                         assert (p == NULL);
 142                         return &p;
 143                 }*/
 144
 145                 noAddrefReleaseOnSmartRefcPtr<T>* operator-> () const
 146                 {
 147 //                      assert (p!=NULL);
 148                         return (noAddrefReleaseOnSmartRefcPtr<T>*)p;
 149                 }
 150
 151                 T* operator= (T* lp)
 152                 {
 153                         T* pp = p;
 154                         if ( (p = lp) != NULL)
 155                                 p->addRef ();
 156                         if (pp)
 157                                 pp->release ();
 158                         return p;
 159                 }
 160
 161                 T* operator= (const smartPtr<T>& lp)
 162                 {
 163                         T* pp = p;
 164                         if ( (p = lp.p) != NULL)
 165                                 p->addRef ();
 166                         if (pp)
 167                                 pp->release ();
 168                         return p;
 169                 }
 170
 171                 template <class N> smartPtr<N> dynamicCast (void) const
 172                 {
 173                         return p ? smartPtr<N> (checked_cast <N*> (p)) : smartPtr<N> (NULL);
 174                 }
 175
 176         };
 177
 178         template <class T> class autoPtr
 179         {
 180
 181         private:
 182
 183                 T*              mpObject;
 184
 185         public:
 186
 187                 autoPtr (T *o)
 188                 {
 189                         assert (o);
 190                         mpObject = o;
 191                 }
 192
 193                 ~autoPtr ()
 194                 {
 195                         delete mpObject;
 196                 }
 197
 198                 operator T* ()
 199                 {
 200                         return mpObject;
 201                 }
 202
 203                 operator const T* () const
 204                 {
 205                         return mpObject;
 206                 }
 207
 208         };
 209
 210 }
 211
 212
 213 #endif // __F_HELPERS_H
 214