Switch array struct to class

[satune.git] / src / Collections / array.h

diff --git a/src/Collections/array.h b/src/Collections/array.h
index d211759470591a2f84990db2d02ac4f7a4716c11..6197de71968b351d30d22a732e425e680793e3b1 100644 (file)
--- a/src/Collections/array.h
+++ b/src/Collections/array.h
@@ -1,55 +1,52 @@
 #ifndef ARRAY_H
 #define ARRAY_H
 
-#define ArrayDef(name, type)                                            \
-       struct Array ## name {                                                \
-               type *array;                                                       \
-               uint size;                                                          \
-       };                                                                    \
-       typedef struct Array ## name Array ## name;                           \
-       static inline Array ## name *allocArray ## name(uint size) {               \
-               Array ## name * tmp = (Array ## name *)ourmalloc(sizeof(type));     \
-               tmp->size = size;                                                   \
-               tmp->array = (type *) ourcalloc(1, sizeof(type) * size);            \
-               return tmp;                                                         \
-       }                                                                     \
-       static inline Array ## name *allocArrayInit ## name(type * array, uint size)  { \
-               Array ## name * tmp = allocArray ## name(size);                     \
-               memcpy(tmp->array, array, size * sizeof(type));                     \
-               return tmp;                                                         \
-       }                                                                     \
-       static inline void removeElementArray ## name(Array ## name * This, uint index) { \
-               This->size--;                                                       \
-               for (; index < This->size; index++) {                                    \
-                       This->array[index] = This->array[index + 1];                          \
-               }                                                                   \
-       }                                                                     \
-       static inline type getArray ## name(Array ## name * This, uint index) { \
-               return This->array[index];                                          \
-       }                                                                     \
-       static inline void setArray ## name(Array ## name * This, uint index, type item) {  \
-               This->array[index] = item;                                            \
-       }                                                                     \
-       static inline uint getSizeArray ## name(Array ## name * This) {                \
-               return This->size;                                                  \
-       }                                                                     \
-       static inline void deleteArray ## name(Array ## name * This) {               \
-               ourfree(This->array);                                               \
-               ourfree(This);                                                      \
-       }                                                                     \
-       static inline type *exposeCArray ## name(Array ## name * This) {             \
-               return This->array;                                                 \
-       }                                                                     \
-       static inline void deleteInlineArray ## name(Array ## name * This) {         \
-               ourfree(This->array);                                               \
-       }                                                                     \
-       static inline void initArray ## name(Array ## name * This, uint size) {     \
-               This->size = size;                                                  \
-               This->array = (type *) ourcalloc(1, sizeof(type) * size);           \
-       }                                                                     \
-       static inline void initArrayInit ## name(Array ## name * This, type * array, uint size) { \
-               initArray ## name(This, size);                                       \
-               memcpy(This->array, array, size * sizeof(type));                    \
-       }
+template<typename type>
+class Array {
+ public:
+ Array(uint _size) :
+       array((type *)ourcalloc(1, sizeof(type) * _size)),
+               size(_size)
+               {
+               }
+  
+ Array(type * _array, uint _size) :
+       array((type *)ourcalloc(1, sizeof(type) * _size)),
+               size(_size) {
+    memcpy(array, _array, _size * sizeof(type));
+  }
+
+  ~Array() {
+    ourfree(array);
+  }
+
+  void remove(uint index) {
+    size--;
+    for (; index < size; index++) {
+      array[index] = array[index + 1];
+    }
+  }
+  
+  type get(uint index) {
+    return array[index];
+  }
+
+  void set(uint index, type item) {
+    array[index] = item;
+  }
+  
+  uint getSize() {
+    return size;
+  }
+
+  type *expose() {
+    return array;
+  }
+
+ private:
+  type *array;
+  uint size;
+};
+
 
 #endif