src/subtitles/libssf/Array.h

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program 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
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #pragma once
  23
  24 namespace ssf
  25 {
  26         // simple array class for simple types without constructors,
  27         // and it doesn't free its reserves on SetCount(0)
  28
  29         template<class T>
  30         class Array
  31         {
  32                 T* m_pData;
  33                 size_t m_nSize;
  34                 size_t m_nMaxSize;
  35                 size_t m_nGrowBy;
  36
  37         public:
  38                 Array() {m_pData = NULL; m_nSize = m_nMaxSize = 0; m_nGrowBy = 4096;}
  39                 virtual ~Array() {if(m_pData) _aligned_free(m_pData);}
  40
  41                 void SetCount(size_t nSize, size_t nGrowBy = 0)
  42                 {
  43                         if(nGrowBy > 0)
  44                         {
  45                                 m_nGrowBy = nGrowBy;
  46                         }
  47
  48                         if(nSize > m_nMaxSize)
  49                         {
  50                                 m_nMaxSize = nSize + max(m_nGrowBy, m_nSize);
  51                                 size_t nBytes = m_nMaxSize * sizeof(T);
  52                                 m_pData = m_pData ? (T*)_aligned_realloc(m_pData, nBytes, 16) : (T*)_aligned_malloc(nBytes, 16);
  53                         }
  54
  55                         m_nSize = nSize;
  56                 }
  57
  58                 size_t GetCount() const {return m_nSize;}
  59
  60                 void RemoveAll() {m_nSize = 0;}
  61                 bool IsEmpty() const {return m_nSize == 0;}
  62
  63                 T* GetData() {return m_pData;}
  64
  65                 void Add(const T& t)
  66                 {
  67                         size_t nPos = m_nSize;
  68                         SetCount(m_nSize+1);
  69                         m_pData[nPos] = t;
  70                 }
  71
  72                 void Append(const Array& a, size_t nGrowBy = 0)
  73                 {
  74                         Append(a.m_pData, a.m_nSize, nGrowBy);
  75                 }
  76
  77                 void Append(const T* ptr, size_t nSize, size_t nGrowBy = 0)
  78                 {
  79                         if(!nSize) return;
  80                         size_t nOldSize = m_nSize;
  81                         SetCount(nOldSize + nSize);
  82                         memcpy(m_pData + nOldSize, ptr, nSize * sizeof(T));
  83                 }
  84
  85                 const T& operator [] (size_t i) const {return m_pData[i];}
  86                 T& operator [] (size_t i) {return m_pData[i];}
  87
  88                 void Copy(const Array& v)
  89                 {
  90                         SetCount(v.GetCount());
  91                         memcpy(m_pData, v.m_pData, m_nSize * sizeof(T));
  92                 }
  93
  94                 void Move(Array& v)
  95                 {
  96                         Swap(v);
  97                         v.SetCount(0);
  98                 }
  99
 100                 void Swap(Array& v)
 101                 {
 102                         T* pData = m_pData; m_pData = v.m_pData; v.m_pData = pData;
 103                         size_t nSize = m_nSize; m_nSize = v.m_nSize; v.m_nSize = nSize;
 104                         size_t nMaxSize = m_nMaxSize; m_nMaxSize = v.m_nMaxSize; v.m_nMaxSize = nMaxSize;
 105                         size_t nGrowBy = m_nGrowBy; m_nGrowBy = v.m_nGrowBy; v.m_nGrowBy = nGrowBy;
 106                 }
 107         };
 108 }