From 1c83c3e87c1bfa2a941da03201d77586e3916006 Mon Sep 17 00:00:00 2001
From: chatlanin <zimin@chatlanin.com.ru>
Date: Wed, 23 Mar 2022 22:02:17 +0300
Subject: [PATCH] add matrix and matrix log

---
 bin/main.cpp                                  | 121 +++++++++------
 bin/meson.build                               |   1 +
 meson.build                                   |  12 +-
 src/concepts/concepts.hpp                     |  11 +-
 .../associative_ostream_iterator.hpp          |  12 +-
 src/iterators/sequence_ostream_iterator.hpp   |  12 +-
 src/logger/logger.cpp                         |  16 +-
 src/logger/logger.hpp                         |  70 +++++----
 src/matrix/matrix.hpp                         | 143 ++++++++++++++++++
 src/matrix/meson.build                        |  14 ++
 src/meson.build                               |   1 +
 11 files changed, 313 insertions(+), 100 deletions(-)
 create mode 100644 src/matrix/matrix.hpp
 create mode 100644 src/matrix/meson.build

diff --git a/bin/main.cpp b/bin/main.cpp
index b77dcc3..e8c3aff 100644
--- a/bin/main.cpp
+++ b/bin/main.cpp
@@ -3,65 +3,92 @@
 #include <map>
 #include <set>
 #include <vector>
+#include <iomanip>
+#include <type_traits>
 
 #include "string/string.hpp"
 #include "range/range.hpp"
 #include "container/container.hpp"
 #include "logger/logger.hpp"
+#include "matrix/matrix.hpp"
+
+#include <string_view>
 
 int main(int argc, char *argv[])
 {
-  {// ex: split_str
-    std::string str { "asdf,qwer,zxcv" };
-    hack::string::v_str v = hack::string::split_str(str, ',');
-    for (const auto& c : v) hack::log()(c);
-  }
+  // {// ex: split_str
+  //   std::string str { "asdf,qwer,zxcv" };
+  //   hack::string::v_str v = hack::string::split_str(str, ',');
+  //   for (const auto& c : v) hack::log()(c);
+  // }
+  //
+  // {// ex: within
+  //   hack::log()(hack::range::within(12, 34, 12, 23, 31, 17, 22, 33));
+  // }
+  //
+  // {// ex: vector_multiset
+  //   std::vector<std::string> v;
+  //   hack::container::vector_multiset(v, "asdf", "qwer", "zcv");
+  //   for(const auto& c : v) std::cout << c << std::endl;
+  // }
+  //
+  // {// ex: set_multiset
+  //   std::set<int> s;
+  //   hack::container::set_multiset(s, 1, 2, 3, 3, 2, 1);
+  //   for(const auto& c : s) std::cout << c << std::endl;
+  // }
+  //
+  // {// ex: log
+  //   hack::log()(1234, "run in main", 1234);
+  //   hack::warn(" # ")(1234, "run in main", 1234);
+  //   hack::error(" - ")(1234, "run in main", 1234);
+  //
+  //   std::string str { "hi" };
+  //   hack::log()(str);
+  //
+  //   std::vector<std::string> vs { "asdf", "qwer", "zxcv" };
+  //   hack::log()("vector", vs, 1, 2, 'a');
+  // 
+  //   std::list<std::string> ls {  "asdf", "qwer", "zxcv" };
+  //   hack::log()(vs, ls);
+  //
+  //   std::map<int, std::string> m { { 1, "asdf" }, { 2, "qwer" }, { 3, "zxcv" } };
+  //   hack::log()(vs, ls, m);
+  //
+  //   std::tuple<int, std::string, bool> tp { 1, "tuple test", false };
+  //   hack::log()(tp);
+  // }
+  //
+  // {// ex: matches
+  //   std::vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+  //   hack::log()(hack::container::matches(v, 2, 5, 4, 12));
+  // }
+  //
+  // {// ex: vector_remove_at
+  //   std::vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+  //   hack::container::vector_remove_at(v, 3);
+  //   hack::log()(v);
+  // }
 
-  {// ex: within
-    hack::log()(hack::range::within(12, 34, 12, 23, 31, 17, 22, 33));
-  }
+  {// ex: matrix
+    hack::matrix<int, 3> m_int;
+    hack::matrix<int, 3> m_int_c;
+    hack::matrix<float, 3> m_float;
 
-  {// ex: vector_multiset
-    std::vector<std::string> v;
-    hack::container::vector_multiset(v, "asdf", "qwer", "zcv");
-    for(const auto& c : v) std::cout << c << std::endl;
-  }
+    m_int[0][0][0] = 123;
+    m_int[0][0][1] = 23;
+    m_int[0][0][2] = 43;
+    m_int_c[0][0][0] = 123;
+    m_float[0][0][0] = 123.123;
 
-  {// ex: set_multiset
-    std::set<int> s;
-    hack::container::set_multiset(s, 1, 2, 3, 3, 2, 1);
-    for(const auto& c : s) std::cout << c << std::endl;
-  }
+    auto i = m_int[0][0][0];
+    auto f = m_float[0][0][0];
 
-  {// ex: log
-    hack::log()(1234, "run in main", 1234);
-    hack::warn(" # ")(1234, "run in main", 1234);
-    hack::error(" - ")(1234, "run in main", 1234);
+    hack::log()("m_int", i); 
+    hack::log()("m_float", f);
 
-    std::string str { "hi" };
-    hack::log()(str);
-
-    std::vector<std::string> vs { "asdf", "qwer", "zxcv" };
-    hack::log()("vector", vs, 1, 2, 'a');
-  
-    std::list<std::string> ls {  "asdf", "qwer", "zxcv" };
-    hack::log()(vs, ls);
-
-    std::map<int, std::string> m { { 1, "asdf" }, { 2, "qwer" }, { 3, "zxcv" } };
-    hack::log()(vs, ls, m);
-
-    std::tuple<int, std::string, bool> tp { 1, "tuple test", false };
-    hack::log()(tp);
-  }
-
-  {// ex: matches
-    std::vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-    hack::log()(hack::container::matches(v, 2, 5, 4, 12));
-  }
-
-  {// ex: vector_remove_at
-    std::vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-    hack::container::vector_remove_at(v, 3);
-    hack::log()(v);
+    hack::log("")("compare (true): ", m_int == m_int_c);
+    hack::log("")("compare (false): ", m_int == m_float);
+    hack::log("")(m_int);
   }
 }
diff --git a/bin/meson.build b/bin/meson.build
index 0c9c1f4..ab8253e 100644
--- a/bin/meson.build
+++ b/bin/meson.build
@@ -5,6 +5,7 @@ deps += string_dep
 deps += range_dep
 deps += container_dep
 deps += logger_dep
+deps += matrix_dep
 
 executable(
   'hack', 'main.cpp', 
diff --git a/meson.build b/meson.build
index d1d1702..1ad4935 100644
--- a/meson.build
+++ b/meson.build
@@ -7,13 +7,21 @@ project(
 )
 
 add_project_arguments (
-  '-pedantic', 
+  '-Wpedantic',
+  '-Wshadow', 
   '-Wno-comment',
-  '-Wno-gnu-zero-variadic-macro-arguments',
+  #'-Wno-gnu-zero-variadic-macro-arguments',
   '-Wunused-but-set-variable',
   language: 'cpp'
 )
 
+compiler = meson.get_compiler('cpp')
+if compiler.get_id() == 'gcc'
+  message('Compiler: GCC')
+elif compiler.get_id() == 'clang'
+  message('Compiler: LLVM/clang')
+endif
+
 args = []
 deps = []
 
diff --git a/src/concepts/concepts.hpp b/src/concepts/concepts.hpp
index d8e99b4..791fbf4 100644
--- a/src/concepts/concepts.hpp
+++ b/src/concepts/concepts.hpp
@@ -18,10 +18,17 @@ namespace hack::concepts
     std::tuple_cat(t, std::make_tuple(1, "tuple"));
   };
 
-  template<class T>
+  template<typename T>
   concept is_string = std::is_convertible_v<T, std::string_view>;
 
-  template<class T>
+  template<typename T>
   concept is_map = std::same_as<T, std::map<typename T::key_type, typename T::mapped_type, typename T::key_compare, typename T::allocator_type>> ||
     std::same_as<T, std::unordered_map<typename T::key_type, typename T::mapped_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>>;
+
+  template<typename T>
+  concept not_defined = !std::enable_if_t<!(std::integral<T> || 
+                                          is_sequence_container<T> || 
+                                          is_map<T> || 
+                                          is_tuple<T> || 
+                                          is_string<T>), bool>() ==  true;
 }
diff --git a/src/iterators/associative_ostream_iterator.hpp b/src/iterators/associative_ostream_iterator.hpp
index 0a550e2..432f6d5 100644
--- a/src/iterators/associative_ostream_iterator.hpp
+++ b/src/iterators/associative_ostream_iterator.hpp
@@ -11,18 +11,18 @@ namespace hack::iterators
     using ostream_type = std::basic_ostream<char, traits>;
 
     private:
-      std::basic_ostream<char, traits>* os;
-      const std::string devider = ", ";
-      std::size_t size;
+      std::basic_ostream<char, traits>* os_;
+      const std::string devider_ = ", ";
+      std::size_t size_;
 
     public:
-      associative_ostream_iterator(std::size_t size, ostream_type& s) : os { &s }, size { size } { }
+      associative_ostream_iterator(std::size_t size, ostream_type& os) : os_ { &os }, size_ { size } { }
 
       auto& operator=(T const& item)
       {
-        --size;
+        --size_;
         const auto& [key, value] = item;
-        *os << "{ " << key << ":" << value << " }" << (size != 0 ? devider : "");
+        *os_ << "{ " << key << ":" << value << " }" << (size_ != 0 ? devider_ : "");
         return *this;
       }
 
diff --git a/src/iterators/sequence_ostream_iterator.hpp b/src/iterators/sequence_ostream_iterator.hpp
index 596ebef..6c2a362 100644
--- a/src/iterators/sequence_ostream_iterator.hpp
+++ b/src/iterators/sequence_ostream_iterator.hpp
@@ -11,17 +11,17 @@ namespace hack::iterators
     using ostream_type = std::basic_ostream<char, traits>;
 
     private:
-      std::basic_ostream<char, traits>* os;
-      const std::string devider = ", ";
-      std::size_t size;
+      std::basic_ostream<char, traits>* os_;
+      const std::string devider_ = ", ";
+      std::size_t size_;
 
     public:
-      sequence_ostream_iterator(std::size_t size, ostream_type& s) : os { &s }, size { size } { }
+      sequence_ostream_iterator(std::size_t size, ostream_type& os) : os_ { &os }, size_ { size } { }
 
       auto& operator=(T const& item)
       {
-        --size;
-        *os << item << (size != 0 ? devider : "");
+        --size_;
+        *os_ << item << (size_ != 0 ? devider_ : "");
         return *this;
       }
 
diff --git a/src/logger/logger.cpp b/src/logger/logger.cpp
index 3981011..d080005 100644
--- a/src/logger/logger.cpp
+++ b/src/logger/logger.cpp
@@ -2,22 +2,22 @@
 
 namespace hack
 {
-  std::string log::devider = " ";
-  int log::count = 0;
+  std::string log::devider_ = " ";
+  int log::count_ = 0;
 
-  log::log(const std::string devider, std::experimental::source_location location) : location { location }
+  log::log(const std::string devider, std::experimental::source_location location) : location_ { location }
   {
-    this->devider = devider;
+    this->devider_ = devider;
   }
 
-  warn::warn(const std::string devider, std::experimental::source_location location) : location { location }
+  warn::warn(const std::string devider, std::experimental::source_location location) : location_ { location }
   {
-   this->devider = devider;
+   this->devider_ = devider;
   }
 
-  error::error(const std::string devider, std::experimental::source_location location) : location { location }
+  error::error(const std::string devider, std::experimental::source_location location) : location_ { location }
   {
-   this->devider = devider;
+   this->devider_ = devider;
   }
 
   void log::print() { std::cout << std::endl; }
diff --git a/src/logger/logger.hpp b/src/logger/logger.hpp
index ec44a3d..f4d881a 100644
--- a/src/logger/logger.hpp
+++ b/src/logger/logger.hpp
@@ -6,6 +6,7 @@
 #include "concepts/concepts.hpp"
 #include "iterators/sequence_ostream_iterator.hpp"
 #include "iterators/associative_ostream_iterator.hpp"
+#include "matrix/matrix.hpp"
 
 namespace hack
 {
@@ -21,17 +22,17 @@ namespace hack
       void operator() (const Args&... args)
       {
         std::cout << make_type_view
-                  << location.file_name() << ":" << view::color::reset 
-                  << view::color::italic << view::color::yellow << location.function_name() << "()" << view::color::reset
-                  << view::color::bold << view::color::blue << "[" << location.line() << "]" << view::color::reset << ": ";
-        count = sizeof...(Args);
+                  << location_.file_name() << ":" << view::color::reset 
+                  << view::color::italic << view::color::yellow << location_.function_name() << "()" << view::color::reset
+                  << view::color::bold << view::color::blue << "[" << location_.line() << "]" << view::color::reset << ": ";
+        count_ = sizeof...(Args);
         print(args...);
       }
 
     private:
-      std::experimental::source_location location;
-      static int count;
-      static std::string devider;
+      std::experimental::source_location location_;
+      static int count_;
+      static std::string devider_;
 
     private:
       static void print();
@@ -45,7 +46,7 @@ namespace hack
       template<typename T, typename... Args>
       static void print(const T& data, const Args&... args)
       {
-        count--;
+        count_--;
         print_t(data);
         print(args...);
       }
@@ -53,13 +54,13 @@ namespace hack
       template<concepts::is_string T>
       static void print_t(const T& data)
       {
-        std::cout << data << (count != 0 ? devider : "");
+        std::cout << data << (count_ != 0 ? devider_ : "");
       }
 
       template<std::integral T>
       static void print_t(const T& data)
       {
-        std::cout << data << (count != 0 ? devider : "");
+        std::cout << data << (count_ != 0 ? devider_ : "");
       }
 
       template<concepts::is_sequence_container T>
@@ -67,7 +68,7 @@ namespace hack
       {
         std::cout << "{ ";
         std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << " }" << (count != 0 ? devider : "");
+        std::cout << " }" << (count_ != 0 ? devider_ : "");
       }
 
       template<concepts::is_map T>
@@ -75,7 +76,7 @@ namespace hack
       {
         std::cout << "{";
         std::copy(data.cbegin(), data.cend(), iterators::associative_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << "}" << (count != 0 ? devider : "");
+        std::cout << "}" << (count_ != 0 ? devider_ : "");
       }
 
       template<concepts::is_tuple T, typename std::size_t... idx>
@@ -88,16 +89,27 @@ namespace hack
       static void print_t(const T& data, std::index_sequence<idx...>)
       {
         std::cout << "{ ";
-        ((std::cout << std::get<idx>(data) << (idx != std::tuple_size<T>::value - 1 ? devider : "")), ...);
-        std::cout << " }" << (count != 0 ? devider : "");
+        ((std::cout << std::get<idx>(data) << (idx != std::tuple_size<T>::value - 1 ? devider_ : "")), ...);
+        std::cout << " }" << (count_ != 0 ? devider_ : "");
       }
 
-      template <template <class, class> typename Function, class ...Args>
-      auto LogCall(std::string fun_name, Function<Args...> fun, std::string fun_param = "", Args... args) 
+      template<typename T, std::size_t demention>
+      static void print_t(const matrix<T, demention>& data)
       {
-        auto temp{ fun(args...) };
-        std::cout << fun_name << "of" << fun_param << "/t -> /t" << temp << '\n';
-        return temp;
+        std::size_t index = data.size();
+        for (auto& r : data)
+        {
+          index--;
+          std::cout << "{ ";
+          print_t(std::get<demention>(r));
+          std::cout << " }" << (index != 0 ? ", " : "");
+        }
+      }
+
+      template<concepts::not_defined T>
+      static void print_t(const T& data)
+      {
+        std::cout << data << (count_ != 0 ? devider_ : "");
       }
 
       friend class warn;
@@ -116,15 +128,15 @@ namespace hack
       void operator() (const Args&... args)
       {
         std::cout << make_type_view
-                  << location.file_name() << ":" << view::color::reset 
-                  << view::color::italic << view::color::yellow << location.function_name() << "()" << view::color::reset
-                  << view::color::bold << view::color::blue << "[" << location.line() << "]" << view::color::reset << ": ";
-        count = sizeof...(Args);
+                  << location_.file_name() << ":" << view::color::reset 
+                  << view::color::italic << view::color::yellow << location_.function_name() << "()" << view::color::reset
+                  << view::color::bold << view::color::blue << "[" << location_.line() << "]" << view::color::reset << ": ";
+        count_ = sizeof...(Args);
         print(args...);
       }
 
     private:
-      std::experimental::source_location location;
+      std::experimental::source_location location_;
 
     private:
       static std::ostream& make_type_view(std::ostream &os)
@@ -146,15 +158,15 @@ namespace hack
       void operator() (const Args&... args)
       {
         std::cout << make_type_view
-                  << location.file_name() << ":" << view::color::reset 
-                  << view::color::italic << view::color::yellow << location.function_name() << "()" << view::color::reset
-                  << view::color::bold << view::color::blue << "[" << location.line() << "]" << view::color::reset << ": ";
-        count = sizeof...(Args);
+                  << location_.file_name() << ":" << view::color::reset 
+                  << view::color::italic << view::color::yellow << location_.function_name() << "()" << view::color::reset
+                  << view::color::bold << view::color::blue << "[" << location_.line() << "]" << view::color::reset << ": ";
+        count_ = sizeof...(Args);
         print(args...);
       }
 
     private:
-      std::experimental::source_location location;
+      std::experimental::source_location location_;
 
     private:
       static std::ostream& make_type_view(std::ostream &os)
diff --git a/src/matrix/matrix.hpp b/src/matrix/matrix.hpp
new file mode 100644
index 0000000..2244abd
--- /dev/null
+++ b/src/matrix/matrix.hpp
@@ -0,0 +1,143 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <tuple>
+#include <algorithm>
+#include <iostream>
+
+namespace hack::matrix_utils
+{
+  template<typename T, size_t N>
+  struct generate_tuple 
+  {
+    using type = decltype(std::tuple_cat(typename generate_tuple<T, N - 1>::type{}, std::make_tuple(T{})));
+  };
+
+  template<typename T>
+  struct generate_tuple<T, 1> 
+  {
+    using type = std::tuple<T>;
+  };
+
+  template<typename T,typename index_data, typename index_t>
+  class proxy
+  {
+    using next_index_t = decltype(std::tuple_cat(index_t{}, std::make_tuple(std::size_t{})));
+
+    public:
+      proxy(const std::weak_ptr<index_data>& local_storage, const index_t& index) : local_storage_ { local_storage }, index_ { index } {};
+
+      auto operator[](std::size_t index) const
+      {
+        return proxy<T, index_data, next_index_t>{ local_storage_, std::tuple_cat(index_, std::make_tuple(index)) };
+      }
+
+      auto& operator=(const T& value)
+      {
+        std::shared_ptr<index_data>(local_storage_)->set_value(index_, value);
+        return *this;
+      }
+
+      operator T() const
+      {
+        return std::shared_ptr<index_data>(local_storage_)->get_value(index_);
+      }
+
+    private:
+      std::weak_ptr<index_data> local_storage_;
+      index_t index_;
+  };
+}
+
+namespace hack
+{
+  template <typename... T, std::size_t... I>
+  auto subtuple_s(const std::tuple<T...>& t, std::index_sequence<I...>) 
+  {
+    return std::make_tuple(std::get<I>(t)...);
+  }
+
+  template <typename... T>
+  auto subtuple(const std::tuple<T...>& t) 
+  {
+    return subtuple_s(t, std::make_index_sequence<sizeof...(T) - 1>());
+  }
+
+  template<typename T, std::size_t dimensions>
+  class matrix
+  {
+    public:
+      matrix() : local_storage_ { new index_data{} } { }
+      
+      auto operator[](std::size_t index)
+      {
+        return matrix_utils::proxy<T, index_data, std::tuple<std::size_t>>{ local_storage_, std::make_tuple(index) };
+      }
+
+      int size() const
+      {
+        return local_storage_->values.size();
+      }
+
+      auto begin() noexcept
+      {
+        return local_storage_->values.begin();
+      }
+
+      auto begin() const noexcept
+      {
+        return local_storage_->values.begin();
+      }
+
+      auto end() noexcept
+      {
+        return local_storage_->values.end();
+      }
+
+      auto end() const noexcept
+      {
+        return local_storage_->values.end();
+      }
+
+      auto cbegin() const noexcept
+      {
+        return local_storage_->values.cbegin();
+      }
+
+      auto cend() const noexcept
+      {
+        return local_storage_->values.cend();
+      }
+
+    private:
+      struct index_data
+      {
+        using index_t = typename matrix_utils::generate_tuple<std::size_t, dimensions>::type;    
+        using index_data_t = std::vector<decltype(std::tuple_cat(index_t{}, std::make_tuple(T{})))>;
+
+        void set_value(const index_t& index, const T& v)
+        {
+          auto value = std::tuple_cat(index, std::make_tuple(v));
+          values.push_back(value);
+        }
+
+        auto get_value(const index_t& index)
+        {
+          auto it = std::find_if(values.begin(), values.end(), [&](auto a) { return subtuple(a) == index; });
+          return std::get<dimensions>(*it);
+        }
+
+        index_data_t values;
+      };
+
+    private:
+      std::shared_ptr<index_data> local_storage_;
+  };
+
+  template <typename T, typename U, std::size_t N>
+  bool operator==(const matrix<T, N>& lhs, const matrix<U, N>& rhs) 
+  { 
+    return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); 
+  }
+}
diff --git a/src/matrix/meson.build b/src/matrix/meson.build
new file mode 100644
index 0000000..3a99718
--- /dev/null
+++ b/src/matrix/meson.build
@@ -0,0 +1,14 @@
+headers = ['matrix.hpp']
+sources = []
+
+lib = library(
+  'matrix',
+  include_directories : inc,
+  install : true,
+  sources: [headers, sources]
+)
+
+matrix_dep = declare_dependency(
+  include_directories: inc,
+  link_with: lib
+)
diff --git a/src/meson.build b/src/meson.build
index 5781e98..fa109f7 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -7,3 +7,4 @@ subdir('string')
 subdir('range')
 subdir('container')
 subdir('logger')
+subdir('matrix')