add array and vector c lib

Author: 7bitcoder

Source/Library/Array.c

@@ -0,0 +1,70 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "Array.h"
+
+struct array
+{
+    size_t size;
+    uint8_t sizeOfType;
+    void *data;
+};
+
+array *array_create(size_t size, size_t sizeOfType)
+{
+    if (size == 0 || sizeOfType == 0)
+    {
+        return NULL;
+    }
+    array *arr = (array *)malloc(sizeof(array));
+    if (arr == NULL)
+    {
+        return NULL;
+    }
+    arr->data = calloc(size, sizeOfType);
+    if (arr->data == NULL)
+    {
+        free(arr);
+        return NULL;
+    }
+    arr->size = size;
+    arr->sizeOfType = sizeOfType;
+    return arr;
+}
+
+void *array_at(array *array, size_t index)
+{
+    if (index >= array_size(array))
+    {
+        return NULL;
+    }
+    uint8_t *casted = (uint8_t *)array->data;
+    uint8_t *ptr = casted + index * array->sizeOfType;
+    return (void *)ptr;
+}
+
+void *array_front(array *array) { return array_at(array, 0); }
+
+void *array_back(array *array) { return array_at(array, array_size(array) - 1); }
+
+size_t array_size(array *array) { return array->size; }
+
+size_t array_size_of_type(array *array) { return array->sizeOfType; }
+
+void *array_data(array *array) { return array->data; }
+
+void array_copy(array *source, array *destination)
+{
+    size_t bytes = array_size(source) * array_size_of_type(source);
+    memcpy(array_data(destination), array_data(source), bytes);
+}
+
+void array_destroy(array *array)
+{
+    if (array == NULL)
+    {
+        return;
+    }
+    free(array->data);
+    free(array);
+}

Source/Library/CMakeLists.txt

@@ -5,7 +5,8 @@ add_library(SandboxLib
   Map.cpp
   Cache.cpp
   MemoryManager.cpp
-  DependencyInjector.cpp
+  Array.c
+  Vector.c
 )
 
 target_include_directories(SandboxLib PUBLIC

Source/Library/Vector.c

@@ -0,0 +1,116 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "Array.h"
+#include "Vector.h"
+
+struct vector
+{
+    size_t size;
+    array *array;
+};
+
+size_t get_array_size(size_t vectorSize)
+{
+    if (vectorSize < 5)
+    {
+        return 5;
+    }
+    return vectorSize + 10;
+}
+
+vector *vector_create(size_t size, size_t sizeOfType)
+{
+    vector *vec = (vector *)malloc(sizeof(vector));
+    if (vec == NULL)
+    {
+        return NULL;
+    }
+
+    array *array = array_create(get_array_size(size), sizeOfType);
+    if (array == NULL)
+    {
+        free(vec);
+        return NULL;
+    }
+    vec->size = size;
+    vec->array = array;
+    return vec;
+}
+
+void *vector_at(vector *vector, size_t index)
+{
+    if (index >= vector_size(vector))
+    {
+        return NULL;
+    }
+    return array_at(vector->array, index);
+}
+
+void *vector_front(vector *vector)
+{
+    if (vector_empty(vector))
+    {
+        return NULL;
+    }
+    return array_front(vector->array);
+}
+
+void *vector_back(vector *vector)
+{
+    if (vector_empty(vector))
+    {
+        return NULL;
+    }
+    return array_at(vector->array, vector_size(vector) - 1);
+}
+
+void *vector_data(vector *vector) { return array_data(vector->array); }
+
+size_t vector_size(vector *vector) { return vector->size; }
+
+bool vector_empty(vector *vector) { return vector_size(vector) == 0; }
+
+void *vector_expand(vector *vector)
+{
+    if (vector_size(vector) < array_size(vector->array))
+    {
+        vector->size++;
+        return vector_back(vector);
+    }
+    size_t newArraySize = get_array_size(vector->size + 1);
+
+    array *newArray = array_create(newArraySize, array_size_of_type(vector->array));
+    if (newArray == NULL)
+    {
+        return NULL;
+    }
+
+    array_copy(vector->array, newArray);
+    array_destroy(vector->array);
+    vector->array = newArray;
+    vector->size++;
+    return vector_back(vector);
+}
+
+void vector_shrink(vector *vector)
+{
+    if (vector->size > 0)
+    {
+        vector->size--;
+    }
+}
+
+void vector_erase(vector *vector, size_t index) {}
+
+void vector_clear(vector *vector) { vector->size = 0; }
+
+void vector_destroy(vector *vector)
+{
+    if (vector == NULL)
+    {
+        return;
+    }
+    array_destroy(vector->array);
+    free(vector);
+}

Source/Library/h/Array.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    typedef struct array array;
+
+    array *array_create(size_t size, size_t sizeOfType);
+
+    void *array_at(array *array, size_t index);
+
+    void *array_front(array *array);
+
+    void *array_back(array *array);
+
+    void *array_data(array *array);
+
+    void array_copy(array *source, array *destination);
+
+    size_t array_size(array *array);
+
+    size_t array_size_of_type(array *array);
+
+    void array_destroy(array *array);
+
+#ifdef __cplusplus
+}
+#endif

Source/Library/h/DependencyInjector.hpp

@@ -21,15 +21,15 @@ namespace sd
     template <class T> class Singeleton
     {
       private:
-        T *_object = nullptr;
+        T *_service = nullptr;
 
       public:
         using Type = T;
 
         Singeleton() = default;
-        Singeleton(T *object) : _object(object) {}
+        Singeleton(T *service) : _service(service) {}
 
-        T *get() const { return _object; }
+        T *get() const { return _service; }
     };
 
     template <int T, class O> class Shared
@@ -69,27 +69,23 @@ namespace sd
         enum Type
         {
             Singeleton = 1,
-            Shared,
-            Unique,
+            Scoped,
+            Transient,
         };
 
       private:
         const Type type;
-        int token = 0;
 
         Scope(Type type) : type(type) {}
-        Scope(int token) : type(Type::Shared), token(token) {}
 
       public:
         static Scope singeleton() { return {Type::Singeleton}; }
-        static Scope unique() { return {Type::Unique}; }
-        static Scope shared(int token) { return {token}; }
+        static Scope transient() { return {Type::Transient}; }
+        static Scope scoped() { return {Type::Scoped}; }
 
         bool isSingeleton() const { return type == Type::Singeleton; }
-        bool isUnique() const { return type == Type::Unique; }
-        bool isShared() const { return type == Type::Shared; }
-
-        int getToken() const { return token; }
+        bool isTransient() const { return type == Type::Transient; }
+        bool isScoped() const { return type == Type::Scoped; }
     };
 
     class DependencyInjector
@@ -354,11 +350,10 @@ namespace sd
 
       public:
         template <class I, class T> void addSingeleton() { add<I, T>(Scope::singeleton()); }
-        template <class I, class T> void addUnique() { add<I, T>(Scope::unique()); }
-        template <class I, class T> void addShared(int token) { add<I, T>(Scope::shared(token)); }
+        template <class I, class T> void addTransient() { add<I, T>(Scope::transient()); }
+        template <class I, class T> void addScoped() { add<I, T>(Scope::scoped()); }
 
-        template <class I> I *getPtr(int token = 0) { return (I *)getFromObjectsMap(typeid(I), token).get(); }
-        template <class I> I &getRef(int token = 0) { return *((I *)getFromObjectsMapSafe(typeid(I), token).get()); }
+        template <class I> std::shared_ptr<I> get() { return (I *)getFromObjectsMap(typeid(I)).get(); }
 
         void build()
         {

Source/Library/h/Path.hpp

@@ -0,0 +1,85 @@
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace sd::filesystem
+{
+    class Path
+    {
+      public:
+        enum Format
+        {
+            Native,
+            Standard,
+            Auto
+        };
+
+      private:
+        Format _format = Auto;
+        std::vector<std::string> _segments;
+
+      public:
+        static const char NativeSeparator;
+        static const char StandardSeparator;
+
+        Path() = default;
+        Path(const Path &path);
+        Path(Path &&path);
+        Path(const std::string &path, Format fmt = Auto);
+        template <class InputIt> Path(InputIt first, InputIt last, Format fmt = Auto);
+
+        Path &operator=(const Path &path);
+        Path &operator=(Path &&path);
+
+        Path &Assign(const Path &path);
+        Path &Assign(Path &&path);
+
+        Path &operator/=(const Path &path);
+        Path &operator/=(Path &&path);
+
+        Path &Append(const Path &path);
+        Path &Append(Path &&path);
+
+        Path &operator+=(const Path &path);
+        Path &operator+=(Path &&path);
+
+        Path &Concat(const Path &path);
+        Path &Concat(Path &&path);
+
+        Path &RemoveFileName();
+        Path &ReplaceFileName(const Path &path);
+        Path &ReplaceExtension(const Path &path);
+
+        std::string ToString() const;
+        std::string ToNativeString() const;
+        std::string ToStandardString() const;
+
+        Path RootName() const;
+        Path RootDirectory() const;
+        Path RootPath() const;
+        Path ParentPath() const;
+        Path FileName() const;
+        Path Extension() const;
+        Path Stem() const;
+
+        bool HasRootName() const;
+        bool HasRootDirectory() const;
+        bool HasRootPath() const;
+        bool HasParentPath() const;
+        bool HasFileName() const;
+        bool HasExtension() const;
+        bool HasStem() const;
+
+        void Swap(Path &path);
+
+        void Clear();
+
+        bool Empty() const;
+
+      private:
+        static Path FromString(std::string path, Path::Format fmt = Path::Format::Auto);
+        static Path FromStringSegments(std::vector<std::string> segments, Path::Format fmt = Path::Format::Auto);
+    };
+} // namespace sd::filesystem