add logger and some tests

bin/main.cpp

@@ -1,7 +1,7 @@
-#include <iostream>
 #include <vector>
 #include <forward_list>
-#include <iostream>
+
+#include "hack/logger/logger.hpp"
 
 #include "hack/mt/algorithms/sort.hpp"
 #include "hack/mt/algorithms/max.hpp"
@@ -14,7 +14,7 @@ auto main(int argc, char *argv[]) -> int
   {
     hack::patterns::ring_buffer<int, 10> rb;
     for (int i = 1; i < 12; ++i) rb.put(i);
-    while(!rb.empty()) std::cout << rb.get().value() << std::endl;
+    hack::log()(rb);
   }
 
   // mt::sort
@@ -25,20 +25,15 @@ auto main(int argc, char *argv[]) -> int
     hack::mt::algorithms::sort(v);
     hack::mt::algorithms::sort(l);
 
-    for (auto d : v)
+    hack::log()(v);
-      std::cout <<  d << " ";
+    hack::log()(l);
-    std::cout << std::endl;
-
-    for (auto d : l)
-      std::cout <<  d << " ";
-    std::cout << std::endl;
   }
 
   // mt::max
   { 
     int a = 4, b = 5; 
     int& c = a;
-    std::cout << hack::mt::algorithms::max(4, 5) << std::endl;
+    hack::log()(hack::mt::algorithms::max(4, 5));
-    std::cout << hack::mt::algorithms::max(c, b) << std::endl;
+    hack::log()(hack::mt::algorithms::max(c, b));
   }
 }

src/hack/logger/logger.hpp

@@ -8,6 +8,8 @@
 #include "hack/iterators/sequence_ostream_iterator.hpp"
 #include "hack/iterators/associative_ostream_iterator.hpp"
 
+#include "hack/patterns/ring_buffer.hpp"
+
 namespace hack
 {
   class log
@@ -133,6 +135,12 @@ namespace hack
         std::cout << data << (count != 0 ? devider : "");
       }
 
+      template<typename T, std::size_t size>
+      static void print_t(const hack::patterns::ring_buffer<T, size>& rb)
+      {
+        print_t(rb.get_src());
+      }
+
       friend class warn;
       friend class error;
   };

src/hack/patterns/ring_buffer.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <array>
 #include <mutex>
 #include <optional>
@@ -56,41 +58,46 @@ namespace hack::patterns
         return val;
       }
 
-      bool empty() noexcept
+      std::array<T, BUFFER_SIZE>& get_src() const noexcept
+      {
+        return m_data;
+      }
+
+      bool empty() const noexcept
       {
         MUTEX lock(m_mutex);
         return (!m_full && (m_head == m_tail));
       }
 
-    size_t size() noexcept
+      std::size_t size() const noexcept
-    {
+      {
-       MUTEX lock(m_mutex);
+         MUTEX lock(m_mutex);
 
-      std::size_t size;
+        std::size_t size;
-      if(!m_full) 
+        if(!m_full) 
-        size = (m_head >= m_tail) ? m_head - m_tail : BUFFER_SIZE - (m_tail - m_head);
+          size = (m_head >= m_tail) ? m_head - m_tail : BUFFER_SIZE - (m_tail - m_head);
-      else 
+        else 
-        size = BUFFER_SIZE;
+          size = BUFFER_SIZE;
 
-      return size;
+        return size;
-    }
+      }
 
-    void reset() noexcept
+      void reset() noexcept
-    {
+      {
-      MUTEX lock(m_mutex);
+        MUTEX lock(m_mutex);
-      m_head = m_tail;
+        m_head = m_tail;
-      m_full = false;
+        m_full = false;
-    }
+      }
 
-    bool full() const noexcept
+      bool full() const noexcept
-    {
+      {
-      return m_full;
+        return m_full;
-    }
+      }
 
-    std::size_t capacity() const noexcept
+      std::size_t capacity() const noexcept
-    {
+      {
-      return BUFFER_SIZE;
+        return BUFFER_SIZE;
-    }
+      }
 
     private:
       void head_refresh()
@@ -106,8 +113,7 @@ namespace hack::patterns
       std::size_t m_tail{ 0 };
 
     private:
-      std::recursive_mutex m_mutex;
+      mutable std::recursive_mutex m_mutex;
-      std::array<T, BUFFER_SIZE> m_data;
+      mutable std::array<T, BUFFER_SIZE> m_data;
   };
 }
-

src/meson.build

@@ -6,7 +6,7 @@ headers = [
   'hack/iterators/associative_ostream_iterator.hpp',
   'hack/iterators/sequence_ostream_iterator.hpp',
 
-  'hack/log/log.hpp',
+  'hack/logger/logger.hpp',
 
   'hack/mt/algorithms/max.hpp',
   'hack/mt/algorithms/sort.hpp',

tests/meson.build

@@ -2,5 +2,5 @@ catch2_with_main_dep = dependency('catch2-with-main')
 dep = [hack_dep, catch2_with_main_dep]
 
 test('patterns', executable('patterns', ['patterns/ring_buffer.cpp'], dependencies : dep))
-test('mt', executable('mt', ['mt/max.cpp'], dependencies : dep))
+test('mt', executable('mt', ['mt/mt.cpp'], dependencies : dep))
 

tests/mt/max.cpp

@@ -1,13 +0,0 @@
-#include "catch2/catch_test_macros.hpp"
-#include "hack/mt/algorithms/max.hpp"
-
-TEST_CASE("mt") 
-{
-  SECTION("max buffer")
-  {
-    int a = 4, b = 5; 
-    int& c = a;
-    REQUIRE(hack::mt::algorithms::max(4, 5) == 5);
-    REQUIRE(hack::mt::algorithms::max(c, b) == 5);
-  }
-}

tests/mt/mt.cpp

@@ -0,0 +1,31 @@
+#include "catch2/catch_test_macros.hpp"
+
+#include <forward_list>
+
+#include "hack/mt/algorithms/max.hpp"
+#include "hack/mt/algorithms/sort.hpp"
+
+TEST_CASE("mt") 
+{
+  SECTION("max")
+  {
+    int a = 4, b = 5; 
+    int& c = a;
+    REQUIRE(hack::mt::algorithms::max(4, 5) == 5);
+    REQUIRE(hack::mt::algorithms::max(c, b) == 5);
+  }
+
+  SECTION("sort")
+  {
+    std::vector<int> v { 4, 4, 6, 1, 4, 3, 2 };
+    std::vector<int> vs { 1, 2, 3, 4, 4, 4, 6  };
+
+    std::forward_list<int> l { 8, 7, 5, 9, 0, 1, 3, 2, 6, 4 };
+    std::forward_list<int> ls { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+    hack::mt::algorithms::sort(v);
+    hack::mt::algorithms::sort(l);
+    REQUIRE(v == vs);
+    REQUIRE(l == ls);
+  }
+}

tests/patterns/ring_buffer.cpp

@@ -1,4 +1,5 @@
 #include "catch2/catch_test_macros.hpp"
+
 #include "hack/patterns/ring_buffer.hpp"
 
 TEST_CASE("patterns")