Class array_t

StereoKitC/libraries/array.h:130–253

template <typename T>
struct array_t {
	T      *data;
	int32_t count;
	int32_t capacity;

	int32_t     add        (const T &item)              { if (count+1   > capacity) { resize(capacity * 2 < 4         ? 4         : capacity * 2); } data[count] = item; count += 1; return count - 1; }
	void        add_range  (const T *list, int32_t num) { if (count+num > capacity) { resize(capacity * 2 < count+num ? count+num : capacity * 2); } ARRAY_MEMCPY(&data[count], list, sizeof(T)*num); count += num; }
	void        insert     (int32_t at, const T &item);
	void        resize     (int32_t to_capacity);
	void        trim       ()                         { resize(count); }
	void        remove     (int32_t at);
	void        pop        ()                         { remove(count - 1); }
	void        clear      ()                         { count = 0; }
	T          &last       () const                   { return data[count - 1]; }
	inline void set        (int32_t id, const T &val) { data[id] = val; }
	inline T   &get        (int32_t id) const         { return data[id]; }
	inline T   &operator[] (int32_t id) const         { return data[id]; }
	void        reverse    ();
	array_t<T>  copy       () const;
	void        each       (void (*e)(T &))             { for (int32_t i=0; i<count; i++) e(data[i]); }
	void        each       (void (*e)(const T &)) const { for (int32_t i=0; i<count; i++) e(data[i]); }
	void        each       (void (*e)(void *))          { for (int32_t i=0; i<count; i++) e(data[i]); }
	template <typename U>
	void        each_with  (U *with, void (*e)(U*, const T &)) const { for (int32_t i=0; i<count; i++) e(with, data[i]); }
	template <typename U>
	U           each_with  (void (*e)(U *, const T &))         const { U result = {}; for (int32_t i = 0; i < count; i++) e(&result, data[i]); }
	template <typename U>
	U           each_sum   (U (*e)(const T &))                 const { U result = 0; for (int32_t i = 0; i < count; i++) result += e(data[i]); return result; }
	template <typename U>
	array_t<U>  each_new   (U    (*e)(const T &)) const { array_t<U> result = {}; result.resize(count); for (int32_t i=0; i<count; i++) result.add(e(data[i])); return result; }
	void        free       ();

	static array_t<T> make     (int32_t capacity)                     { array_t<T> result = {}; result.resize(capacity); return result; }
	static array_t<T> make_fill(int32_t capacity, const T &copy_from) { array_t<T> result = {}; result.resize(capacity); result.count = capacity; for(int32_t i=0;i<capacity;i+=1) result.data[i]=copy_from; return result; }
	static array_t<T> make_from(T *use_memory, int32_t count)         { return {use_memory, count, count}; }

	//////////////////////////////////////
	// Linear search methods

	int32_t     index_of   (const T &item) const                                              { for (int32_t i = 0; i < count; i++) if (memcmp(&data[i], &item, sizeof(T)) == 0) return i; return -1; }
	template <typename _T, typename D>
	int32_t     index_where(const D _T::*key, const D &item) const                            { const size_t offset = (size_t)&((_T*)0->*key); for (int32_t i = 0; i < count; i++) if (memcmp(((uint8_t *)&data[i]) + offset, &item, sizeof(D)) == 0) return i; return -1; }
	int32_t     index_where(bool (*c)(const T &item, void *user_data), void *user_data) const { for (int32_t i=0; i<count; i++) if (c(data[i], user_data)) return i; return -1;}
	int32_t     index_where(bool (*c)(const T &item)) const                                   { for (int32_t i=0; i<count; i++) if (c(data[i]))            return i; return -1;}
	int32_t     index_best_small(int32_t (*c)(const T &item)) const                           { int32_t best = 0x7fffffff; int32_t result = -1; for (int32_t i=0; i<count; i++) { int32_t r = c(data[i]); if (r < best) { best = r; result = i;} } return result; }
	int32_t     index_best_large(int32_t (*c)(const T &item)) const                           { int32_t best = 0x80000000; int32_t result = -1; for (int32_t i=0; i<count; i++) { int32_t r = c(data[i]); if (r > best) { best = r; result = i;} } return result;}
	template <typename U>
	int32_t     index_best_small_with(U with, int32_t (*c)(U, const T &item)) const                           { int32_t best = 0x7fffffff; int32_t result = -1; for (int32_t i=0; i<count; i++) { int32_t r = c(with, data[i]); if (r < best) { best = r; result = i;} } return result; }
	template <typename U>
	int32_t     index_best_large_with(U with, int32_t (*c)(U, const T &item)) const                           { int32_t best = -0x80000000; int32_t result = -1; for (int32_t i=0; i<count; i++) { int32_t r = c(with, data[i]); if (r > best) { best = r; result = i;} } return result; }

	//////////////////////////////////////
	// Binary search methods

	int32_t binary_search(const T &item) const;

	// Extra template parameters mean this needs completely defined right here.
	// Does not work on pointers.