include/blt/std/queue.h

@@ -10,16 +10,14 @@
 /**
  *
  */
-namespace blt
+namespace blt {
-{
     
     /**
      * Standard array backed first in first out queue
      * @tparam T type stored in the queue
      */
     template<typename T>
-    class flat_stack
+    class flat_stack {
-    {
         private:
             int m_size = 16;
             int m_insertIndex = 0;
@@ -30,8 +28,7 @@ namespace blt
              * and deletes the old array from memory.
              * @param newSize new size of the internal array
              */
-            void expand()
+            void expand() {
-            {
                 int new_size = m_size * 2;
                 auto tempData = new T[new_size];
                 for (int i = 0; i < m_insertIndex; i++)
@@ -43,10 +40,8 @@ namespace blt
         
         public:
             
-            void push(const T& t)
+            void push(const T& t) {
-            {
+                if (m_insertIndex >= m_size) {
-                if (m_insertIndex >= m_size)
-                {
                     expand();
                 }
                 m_data[m_insertIndex++] = t;
@@ -56,30 +51,25 @@ namespace blt
              * Warning does not contain runtime error checking!
              * @return the element at the "front" of the queue.
              */
-            [[nodiscard]] const T& top() const
+            [[nodiscard]] const T& top() const {
-            {
                 return m_data[m_insertIndex - 1];
             }
             
-            void pop()
+            void pop() {
-            {
                 if (empty())
                     return;
                 m_insertIndex--;
             }
-            
+        
-            [[nodiscard]] inline bool empty() const
+            [[nodiscard]] inline bool empty() const {
-            {
                 return m_insertIndex <= 0;
             }
-            
+        
-            [[nodiscard]] inline int size() const
+            [[nodiscard]] inline int size() const {
-            {
                 return m_insertIndex;
             }
             
-            ~flat_stack()
+            ~flat_stack() {
-            {
                 delete[](m_data);
             }
     };
@@ -89,19 +79,16 @@ namespace blt
      * @tparam T type stored in the queue
      */
     template<typename T>
-    class flat_queue
+    class flat_queue {
-    {
         private:
             int m_size = 16;
             int m_headIndex = 0;
             int m_insertIndex = 0;
             T* m_data;
-            
             /**
              * Expands the internal array to allow for more storage of elements
              */
-            void expand()
+            void expand() {
-            {
                 int new_size = m_size * 2;
                 int removed_size = m_size - m_headIndex;
                 auto tempData = new T[new_size];
@@ -116,15 +103,12 @@ namespace blt
             }
         
         public:
-            flat_queue(): m_data(new T[m_size])
+            flat_queue(): m_data(new T[m_size]) {
-            {
             
             }
-            
+        
-            inline void push(const T& t)
+            inline void push(const T& t) {
-            {
+                if (m_insertIndex+1 >= m_size) {
-                if (m_insertIndex + 1 >= m_size)
-                {
                     expand();
                 }
                 m_data[m_insertIndex++] = t;
@@ -134,106 +118,36 @@ namespace blt
              * Warning does not contain runtime error checking!
              * @return the element at the "front" of the queue.
              */
-            [[nodiscard]] const T& front() const
+            [[nodiscard]] const T& front() const {
-            {
                 return m_data[m_headIndex];
             }
-            
+        
-            [[nodiscard]] T& front()
+            inline void pop() {
-            {
-                return m_data[m_headIndex];
-            }
-            
-            inline void pop()
-            {
                 if (empty())
                     return;
                 m_headIndex++;
             }
             
-            [[nodiscard]] inline bool empty() const
+            [[nodiscard]] inline bool empty() const {
-            {
                 return m_headIndex >= m_size;
             }
             
-            [[nodiscard]] inline int size() const
+            [[nodiscard]] inline int size() const {
-            {
                 return m_insertIndex - m_headIndex;
             }
-            
+        
-            inline T* begin()
+            inline T* begin(){
-            {
                 return m_data[m_headIndex];
             }
-            
+        
-            inline T* end()
+            inline T* end(){
-            {
                 return m_data[m_insertIndex];
             }
             
-            ~flat_queue()
+            ~flat_queue() {
-            {
                 delete[](m_data);
             }
     };
-    
-    template<typename T>
-    class linked_stack
-    {
-        private:
-            struct node
-            {
-                T t;
-                node* next;
-                
-                node(const T& t, node* node): t(t), next(node)
-                {}
-                
-                node(T&& t, node* node): t(std::move(t)), next(node)
-                {}
-            };
-            
-            node* head = nullptr;
-        public:
-            inline void push(const T& t)
-            {
-                head = new node(t, head);
-            }
-            
-            inline void push(T&& t)
-            {
-                head = new node(std::move(t), head);
-            }
-            
-            inline T& top()
-            {
-                return head->t;
-            }
-            
-            
-            inline const T& top() const
-            {
-                return head->t;
-            }
-            
-            inline void pop()
-            {
-                auto* h = head;
-                head = head->next;
-                delete h;
-            }
-            
-            ~linked_stack()
-            {
-                auto* h = head;
-                while (h != nullptr)
-                {
-                    auto* hc = h;
-                    h = h->next;
-                    delete hc;
-                }
-            }
-    };
 }
 
 #endif //BLT_QUEUE_H

tests/include/blt_tests.h

@@ -1,40 +0,0 @@
-/*
- *  <Short Description>
- *  Copyright (C) 2023  Brett Terpstra
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef BLT_BLT_TESTS_H
-#define BLT_BLT_TESTS_H
-
-#include <memory_test.h>
-#include <blt/parse/argparse.h>
-#include <utility_test.h>
-#include <blt/std/utility.h>
-
-namespace blt::test
-{
-    namespace data
-    {
-        void run();
-    }
-    
-    namespace sys
-    {
-    
-    }
-}
-
-#endif //BLT_BLT_TESTS_H

tests/src/datastructure_tests.cpp

@@ -1,108 +0,0 @@
-/*
- *  <Short Description>
- *  Copyright (C) 2023  Brett Terpstra
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-#include <blt_tests.h>
-#include <blt/std/queue.h>
-#include <queue>
-#include <stack>
-#include <vector>
-#include <blt/profiling/profiler_v2.h>
-#include <random>
-#include <cmath>
-
-namespace blt
-{
-    
-    constexpr size_t max_size = 100000000;
-    constexpr size_t min_size = 10000;
-    
-    size_t exp(size_t base, size_t e)
-    {
-        size_t collect = 1;
-        for (size_t i = 0; i < e; i++)
-            collect *= base;
-        return collect;
-    }
-    
-    void run_size(size_t size)
-    {
-        std::vector<int> random_data;
-        std::random_device dev;
-        std::mt19937_64 engine(dev());
-        std::uniform_int_distribution gen(std::numeric_limits<int>::min(), std::numeric_limits<int>::max());
-        
-        for (size_t i = 0; i < size; i++)
-            random_data.push_back(gen(engine));
-        
-        auto insertProfile = "Insert (" + std::to_string(size) += ')';
-        auto readProfile = "Read (" + std::to_string(size) += ')';
-        
-        std::stack<int> std_stack;
-        BLT_START_INTERVAL(insertProfile, "std::stack");
-        for (size_t i = 0; i < size; i++)
-            std_stack.push(random_data[i]);
-        BLT_END_INTERVAL(insertProfile, "std::stack");
-        
-        blt::flat_stack<int> blt_flat_stack;
-        BLT_START_INTERVAL(insertProfile, "blt::flat_stack");
-        for (size_t i = 0; i < size; i++)
-            blt_flat_stack.push(random_data[i]);
-        BLT_END_INTERVAL(insertProfile, "blt::flat_stack");
-        
-        blt::linked_stack<int> blt_linked_stack;
-        BLT_START_INTERVAL(insertProfile, "blt::linked_stack");
-        for (size_t i = 0; i < size; i++)
-            blt_linked_stack.push(random_data[i]);
-        BLT_END_INTERVAL(insertProfile, "blt::linked_stack");
-        
-        BLT_START_INTERVAL(readProfile, "std::stack");
-        for (size_t i = 0; i < size; i++)
-        {
-            blt::black_box(std_stack.top());
-            std_stack.pop();
-        }
-        BLT_END_INTERVAL(readProfile, "std::stack");
-        
-        BLT_START_INTERVAL(readProfile, "blt::flat_stack");
-        for (size_t i = 0; i < size; i++)
-        {
-            blt::black_box(blt_flat_stack.top());
-            blt_flat_stack.pop();
-        }
-        BLT_END_INTERVAL(readProfile, "blt::flat_stack");
-        
-        BLT_START_INTERVAL(readProfile, "blt::linked_stack");
-        for (size_t i = 0; i < size; i++)
-        {
-            blt::black_box(blt_linked_stack.top());
-            blt_linked_stack.pop();
-        }
-        BLT_END_INTERVAL(readProfile, "blt::linked_stack");
-        
-        BLT_PRINT_PROFILE(insertProfile);
-        BLT_PRINT_PROFILE(readProfile);
-    }
-    
-    void test::data::run()
-    {
-        auto max = static_cast<size_t>(std::log10(max_size));
-        auto min = static_cast<size_t>(std::log10(min_size));
-        for (size_t i = min; i <= max; i++)
-            run_size(exp(10, i));
-    }
-    
-}

tests/src/main.cpp

@@ -11,7 +11,10 @@
 //#include <bitset>
 //#include "hashmap_tests.h"
 //#include <functional>
-#include <blt_tests.h>
+#include <memory_test.h>
+#include <blt/parse/argparse.h>
+#include <utility_test.h>
+#include <blt/std/utility.h>
 
 std::function<int(int i)> test{
         [](int i) -> int {
@@ -68,7 +71,6 @@ int main(int argc, const char** argv)
                     .setAction(blt::arg_action_t::STORE)
                     .setNArgs('?').build());
     parser.addArgument(blt::arg_builder("--utility").setHelp("Run tests on utility functions").setAction(blt::arg_action_t::STORE_TRUE).build());
-    parser.addArgument(blt::arg_builder("--data").setHelp("Run tests on data functions").setAction(blt::arg_action_t::STORE_TRUE).build());
     
     auto args = parser.parse_args(argc, argv);
     
@@ -85,9 +87,6 @@ int main(int argc, const char** argv)
     if (args.contains("--memory"))
         blt::test::memory::run();
     
-    if (args.contains("--data"))
-        blt::test::data::run();
-    
     if (args.contains("--nbt"))
     {
         auto v = blt::arg_parse::get<std::string>(args["nbt"]);