WDL/poollist.h

   1 /*
   2   WDL - poollist.h
   3   Copyright (C) 2006 and later, Cockos Incorporated
   4
   5   This software is provided 'as-is', without any express or implied
   6   warranty.  In no event will the authors be held liable for any damages
   7   arising from the use of this software.
   8
   9   Permission is granted to anyone to use this software for any purpose,
  10   including commercial applications, and to alter it and redistribute it
  11   freely, subject to the following restrictions:
  12
  13   1. The origin of this software must not be misrepresented; you must not
  14      claim that you wrote the original software. If you use this software
  15      in a product, an acknowledgment in the product documentation would be
  16      appreciated but is not required.
  17   2. Altered source versions must be plainly marked as such, and must not be
  18      misrepresented as being the original software.
  19   3. This notice may not be removed or altered from any source distribution.
  20
  21
  22
  23   This file defines a template class for hosting lists of referenced count, string-identified objects.
  24
  25   We mostly use it with WDL_ResourcePool, but any class like this can use it:
  26
  27
  28   class SomeClass
  29   {
  30   public:
  31     SomeClass(char *identstr) { WDL_POOLLIST_identstr=identstr; WDL_POOLLIST_refcnt=0; }
  32     ~SomeClass() {}  // do NOT free or delete WDL_POOLLIST_identstr
  33
  34
  35     void Clear() {}  // will be called if ReleasePool(x,false) is called and refcnt gets to 0
  36     int WDL_POOLLIST_refcnt;
  37     char *WDL_POOLLIST_identstr;
  38   };
  39
  40
  41
  42 */
  43
  44
  45
  46 #ifndef _WDL_POOLLIST_H_
  47 #define _WDL_POOLLIST_H_
  48
  49 #include <stdlib.h>
  50
  51 #include "mutex.h"
  52
  53 template<class DATATYPE> class WDL_PoolList_NoFreeOnDestroy
  54 {
  55 public:
  56
  57   WDL_PoolList_NoFreeOnDestroy()
  58   {
  59   }
  60   ~WDL_PoolList_NoFreeOnDestroy()
  61   {
  62   }
  63
  64   DATATYPE *Get(const char *filename, bool createIfExists=true)
  65   {
  66     WDL_MutexLock lock(&mutex);
  67
  68     DATATYPE *t = Find(filename,false);
  69     if (t)
  70     {
  71       t->WDL_POOLLIST_refcnt++;
  72       return t;
  73     }
  74     if (!createIfExists) return NULL;
  75
  76     t = new DATATYPE(strdup(filename));
  77     t->WDL_POOLLIST_refcnt=1;
  78
  79     int x;
  80     for(x=0;x<pool.GetSize();x++) if (stricmp(pool.Get(x)->WDL_POOLLIST_identstr,filename)>0) break;
  81
  82     pool.Insert(x,t);
  83
  84     return t;
  85   }
  86
  87   DATATYPE *Find(const char *filename, bool lockMutex=true) // not threadsafe
  88   {
  89     if (lockMutex) mutex.Enter();
  90     DATATYPE  **_tmp=NULL;
  91     if (pool.GetSize())
  92     {
  93       DATATYPE tmp((char *)filename),*t=&tmp;
  94       _tmp = (DATATYPE**)bsearch(&t,pool.GetList(),pool.GetSize(),sizeof(void *),_sortfunc);
  95     }
  96     if (lockMutex) mutex.Leave();
  97     return _tmp ? *_tmp : NULL;
  98   }
  99
 100   int ReleaseByName(const char *filename, bool isFull=true)
 101   {
 102     WDL_MutexLock lock(&mutex);
 103     return Release(Find(filename,false),isFull);
 104   }
 105
 106   int Release(DATATYPE *tp, bool isFull=true)
 107   {
 108     if (!tp) return -1;
 109     WDL_MutexLock lock(&mutex);
 110
 111     int refcnt;
 112     if (!(refcnt=--tp->WDL_POOLLIST_refcnt))
 113     {
 114       if (!isFull)
 115       {
 116         tp->Clear();
 117       }
 118       else
 119       {
 120         int x;
 121         for (x = 0; x < pool.GetSize() && pool.Get(x) != tp; x ++);
 122         if (x<pool.GetSize())
 123         {
 124           pool.Delete(x);
 125         }
 126         free(tp->WDL_POOLLIST_identstr);
 127         delete tp;
 128       }
 129       // remove from list
 130     }
 131     return refcnt;
 132   }
 133
 134   void RemoveAll()
 135   {
 136     int x;
 137     for (x = 0; x < pool.GetSize(); x ++)
 138     {
 139       DATATYPE *p = pool.Get(x);
 140       free(p->WDL_POOLLIST_identstr);
 141       delete p;
 142     }
 143     pool.Empty();
 144   }
 145
 146   WDL_Mutex mutex;
 147   WDL_PtrList< DATATYPE > pool;
 148
 149 private:
 150
 151   static int _sortfunc(const void *a, const void *b)
 152   {
 153     DATATYPE *ta = *(DATATYPE **)a;
 154     DATATYPE *tb = *(DATATYPE **)b;
 155
 156     return stricmp(ta->WDL_POOLLIST_identstr,tb->WDL_POOLLIST_identstr);
 157   }
 158 };
 159
 160 template<class DATATYPE> class WDL_PoolList : public WDL_PoolList_NoFreeOnDestroy<DATATYPE>
 161 {
 162 public:
 163   WDL_PoolList() { }
 164   ~WDL_PoolList() { WDL_PoolList_NoFreeOnDestroy<DATATYPE>::RemoveAll(); }
 165
 166
 167 };
 168
 169 #endif