Shamusworld >> Repos - guemap/blob - src/array.h

   1 //\r
   2 // GUEmap\r
   3 // Copyright 1997-2007 by Christopher J. Madsen\r
   4 // (C) 2019 James Hammons\r
   5 //\r
   6 // GUEmap is licensed under either version 2 of the GPL, or (at your option)\r
   7 // any later version.  See LICENSE file for details.\r
   8 //\r
   9 // Template class for dynamic array (based on STL vector)\r
  10 //\r
  11 \r
  12 #ifndef __ARRAY_H__\r
  13 #define __ARRAY_H__\r
  14 \r
  15 // CURRENTLY included by globals.h.  !!! FIX !!!\r
  16 \r
  17 //#include "globals.h"\r
  18 typedef vector<uint8_t>::size_type VecSize;\r
  19 \r
  20 //typedef Array<MapRoom, RoomVec> RoomArray;\r
  21 //Type == MapRoom, TVec == RoomVec == vector<MapRoom *>\r
  22 \r
  23 //template <class Type, class TVec>\r
  24 class RoomArray\r
  25 {\r
  26         public:\r
  27                 RoomVec v;\r
  28 \r
  29         public:\r
  30                 RoomArray() {}\r
  31                 RoomArray(RoomVec & v2) { v.swap(v2); }\r
  32                 ~RoomArray() { RoomArray::removeAll(); }\r
  33 \r
  34                 MapRoom & operator[](VecSize pos)\r
  35                 {\r
  36                         ASSERT(pos < v.size());\r
  37                         return *v[pos];\r
  38                 }\r
  39 \r
  40                 const MapRoom & operator[](VecSize pos) const\r
  41                 {\r
  42                         ASSERT(pos < v.size());\r
  43                         return *v[pos];\r
  44                 }\r
  45 \r
  46                 bool empty() const\r
  47                 {\r
  48                         return v.empty();\r
  49                 }\r
  50 \r
  51                 MapRoom * extract(VecSize pos)\r
  52                 {\r
  53                         ASSERT(pos < v.size());\r
  54                         MapRoom * r = v[pos];\r
  55                         v.erase(v.begin() + pos);\r
  56                         return r;\r
  57                 }\r
  58 \r
  59                 void extractAll(RoomVec & v2) { v2.clear(); v.swap(v2); }\r
  60 \r
  61                 MapRoom * getPtr(VecSize pos)\r
  62                 {\r
  63                         ASSERT(pos < v.size());\r
  64                         return v[pos];\r
  65                 }\r
  66 \r
  67                 const MapRoom * getPtr(VecSize pos) const\r
  68                 {\r
  69                         ASSERT(pos < v.size());\r
  70                         return v[pos];\r
  71                 }\r
  72 \r
  73                 RoomVec & getVector()\r
  74                 {\r
  75                         return v;\r
  76                 }\r
  77 \r
  78                 const RoomVec & getVector() const\r
  79                 {\r
  80                         return v;\r
  81                 }\r
  82 \r
  83                 void append(MapRoom * obj)\r
  84                 {\r
  85                         v.insert(v.end(), obj);\r
  86                 }\r
  87 \r
  88                 void insert(VecSize pos, MapRoom * obj)\r
  89                 {\r
  90                         ASSERT(pos <= v.size());\r
  91                         v.insert(v.begin() + pos, obj);\r
  92                 }\r
  93 \r
  94                 void remove(VecSize pos)\r
  95                 {\r
  96                         ASSERT(pos < v.size());\r
  97                         delete v[pos];\r
  98                         v.erase(v.begin() + pos);\r
  99                 }\r
 100 \r
 101                 RoomVec::iterator remove(RoomVec::iterator itr)\r
 102                 {\r
 103                         delete *itr;\r
 104                         return v.erase(itr);\r
 105                 }\r
 106 \r
 107                 void removeAll()\r
 108                 {\r
 109                         RoomVec::iterator p = v.begin();\r
 110 \r
 111                         while (p != v.end())\r
 112                                 delete *(p++);\r
 113 \r
 114                         v.clear();\r
 115                 }\r
 116 \r
 117                 void reserve(VecSize n)\r
 118                 {\r
 119                         v.reserve(n);\r
 120                 }\r
 121 \r
 122                 void resize(VecSize n)\r
 123                 {\r
 124                         ASSERT(v.size() <= n);\r
 125                         v.insert(v.end(), n - v.size(), NULL);\r
 126                 }\r
 127 \r
 128                 VecSize size() const\r
 129                 {\r
 130                         return v.size();\r
 131                 }\r
 132 \r
 133                 RoomArray & operator=(const RoomArray & source)\r
 134                 {\r
 135                         if (this != &source)\r
 136                         {\r
 137                                 removeAll();\r
 138                                 v.reserve(source.v.size());\r
 139 \r
 140                                 for(RoomVec::const_iterator e=source.v.begin(); e!=source.v.end(); e++)\r
 141                                         append(new MapRoom(**e));\r
 142                         }\r
 143 \r
 144                         return *this;\r
 145                 }\r
 146 \r
 147                 bool operator==(const RoomArray & x) const\r
 148                 {\r
 149                         if (v.size() != x.v.size())\r
 150                                 return false;\r
 151 \r
 152                         for(RoomVec::const_iterator a=v.begin(), b=x.v.begin(); a!=v.end(); a++, b++)\r
 153                         {\r
 154                                 if (**a != **b)\r
 155                                         return false;\r
 156                         }\r
 157 \r
 158                         return true;\r
 159                 }\r
 160 };\r
 161 \r
 162 #endif  // __ARRAY_H__\r
 163 \r