Small edit

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

diff --git a/src/Collections/array.h b/src/Collections/array.h
index 19a22b3cdb7c947a70204f05623dfd53aa9a8212..496bdc65613e0586d2ad7de75bff3c8a7ab05422 100644 (file)
--- a/src/Collections/array.h
+++ b/src/Collections/array.h
@@ -1,49 +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 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