osh.h

commit 1584792d97564bd69f454bf6ae41b83ce6427b58
parent 4bf4a9f186a7456b8b15f2676de458afed3afdb0
Author: Oshgnacknak <osh@oshgnacknak.de>
Date:   Wed, 26 Jan 2022 23:29:00 +0100

Add DArray with example

Diffstat:
A
examples/darray.cpp
 | 
23
+++++++++++++++++++++++
M
osh.h
 | 
54
++++++++++++++++++++++++++++++++++++++++++++++++++++++

2 files changed, 77 insertions(+), 0 deletions(-)
diff --git a/examples/darray.cpp b/examples/darray.cpp
@@ -0,0 +1,23 @@
+#include "osh.h"
+
+using namespace osh;
+
+int main() {
+    DArray<int> fib;
+
+    fib.push(0);
+    fib.push(1);
+
+    for (int i = 0; i < 20; i++) {
+        fib.push(fib[-1] + fib[-2]);
+    }
+
+    for (int i = 0; i < fib.size(); i++) {
+        println(i, ": ", fib[i]);
+    }
+
+    return 0;
+}
+
+#define OSH_H_IMPLEMENTATION
+#include "osh.h"
diff --git a/osh.h b/osh.h
@@ -78,6 +78,22 @@ namespace osh {
         ~AutoDestruct();
     };
 
+    template<typename T>
+    class DArray {
+    protected:
+        T* elements;
+        size_t size_ = 0;
+        size_t capacity;
+    public:
+        DArray(size_t = 10);
+        void destruct();
+        size_t size() const;
+        void ensureCapacity(size_t);
+        void push(const T&);
+        void clear();
+        T& operator[](ssize_t);
+    };
+
     template<Destructible T>
     AutoDestruct<T> autoDestruct(T t);
 
@@ -265,16 +281,54 @@ namespace osh {
         data = (char*) malloc(capacity);
         if (capacity > 0) {
             data[0] = '\0';
+
+    template<typename T>
+    DArray<T>::DArray(size_t capacity) : capacity(capacity) {
+        elements = (T*) malloc(sizeof(T) * capacity);
+    }
+
+    template<typename T>
+    void DArray<T>::destruct() {
+        if (elements != nullptr) {
+            free(elements);
+        }
+    }
+
+    template<typename T>
+    size_t DArray<T>::size() const {
+        return size_;
+    }
+
+    template<typename T>
+    void DArray<T>::ensureCapacity(size_t required) {
+        if (size_ + required >= capacity) {
+            capacity = max(capacity *= 2, size_ + required);
+            elements = (T*) realloc(elements, sizeof(T) * capacity);
         }
     }
 
     StringBuffer::StringBuffer(const char* data) : StringBuffer(strlen(data)) {
         _size = capacity;
         memcpy(this->data, data, _size);
+    template<typename T>
+    void DArray<T>::push(const T& t) {
+        ensureCapacity(1);
+        elements[size_++] = t;
+    }
+
+    template<typename T>
+    void DArray<T>::clear() {
+        size_ = 0;
     }
 
     int StringBuffer::size() const {
         return _size;
+    template<typename T>
+    T& DArray<T>::operator[](ssize_t index) {
+        index = listIndex(index, size_);
+        return elements[index];
+    }
+
     }
 
     char* StringBuffer::cstr() const {