add primary container and concepts for logger

2025-09-10 00:10:30 +03:00
parent 86d4535401
commit 057dc595ac
5 changed files with 246 additions and 81 deletions
--- a/bin/examples/concepts/main.cpp
+++ b/bin/examples/concepts/main.cpp
@@ -66,13 +66,6 @@ void example_is_sequence_container(const T& container)
  hack::log()("Sequence container with ", container.size(), " elements");
 }

-template<hack::concepts::is_random_access_container T>
-void example_is_random_access_container(T& container) 
-{
-  if (!container.empty()) 
-    hack::log()("First element: ", container[0]);
-}
-
 template<hack::concepts::is_container_adapter T>
 void example_is_container_adapter(T& adapter) 
 {
@@ -139,15 +132,6 @@ void check_support(const T& value)
    hack::log()("Type is supported");
 }

-template<hack::concepts::has_key_value_semantics T>
-void example_has_key_value_semantics(T& container) 
-{
-  if constexpr (hack::concepts::has_mapped_type<T>) 
-    hack::log()("Key-value container, sample access demonstrated");
-  else 
-    hack::log()("Set-like container");
-}
-
 template<hack::concepts::is_contiguous_container T>
 void example_is_contiguous_container(const T& container) 
 {
@@ -210,9 +194,7 @@ auto main(int argc, char *argv[]) -> int
  example_is_string(str);
  example_is_sequence_container(vec);
  example_is_sequence_container(list);
-  example_is_random_access_container(vec);
  example_is_container_adapter(stack);
-  example_is_associative_container(set);
  example_is_unordered_associative_container(umap);
  example_is_tuple_like(tuple);
  example_is_fixed_array(fixed_array);
@@ -222,7 +204,6 @@ auto main(int argc, char *argv[]) -> int
  example_is_sized(vec);
  check_support(a);
  check_support(custom);
-  example_has_key_value_semantics(map);
  example_is_contiguous_container(vec);
  example_can_push_front(list, 0);
  example_can_push_back(vec, 99);
--- a/bin/examples/logger/main.cpp
+++ b/bin/examples/logger/main.cpp
@@ -1,4 +1,6 @@
 #include <vector>
+#include <set>
+#include <unordered_set>
 #include <map>
 #include "hack/logger/logger.hpp"

@@ -9,15 +11,48 @@ auto main(int argc, char *argv[]) -> int
  double d = 2.0;
  float f = 3.f;
  std::vector<std::string> vs = { "a", "b", "c" };
+  std::list<int> l = { 1, 2, 3 };
+  std::deque<float> df = { 1.1f, 2.1f, 3.1f };
+  std::forward_list<int> fl = { 1, 2, 3 };
  std::map<int, int> mi = { { 1, 1 }, { 2, 2 }, { 3, 3 } };
+  std::multimap<int, int> mmi = { { 1, 1 }, { 1, 1 }, { 2, 2 }, { 3, 3 } };
+  std::unordered_map<int, int> umi = { { 1, 1 }, { 1, 1 }, { 2, 2 }, { 3, 3 } };
+  std::tuple<int, std::string, bool> tp = { 1, "asdf", false };
+  std::stack<int> sti;
+  sti.push(1);
+  sti.push(2);
+  sti.push(3);
+  std::set<int> si = { 1, 2, 3 };
+  std::unordered_set<int> usi = { 1, 1, 1 };

  hack::log().set_devider(", ");
  hack::log().no_func();
-  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+  hack::log()(1, i, 3.1f, f, 4.3, d, "asdf");
  hack::log().set_devider(" = ");
-  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+  hack::log()(1, i, 3.1f, f, 4.3, d, "asdf");
  hack::log().reset();
-  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+  hack::log()(1, i, 3.1f, f, 4.3, d, "asdf");
+  hack::log().set_devider(", ");
+  hack::log().no_func();
+  hack::log().no_file();
+  hack::log().no_row();
+  hack::log()(vs);
+  hack::log()(l);
+  hack::log()(df);
+  hack::log()(fl);
+  hack::log().reset();
+  hack::log()(mi);
+  hack::log()(mmi);
+  hack::log()(umi);
+  hack::log()(tp);
+  hack::log()(true);
+  hack::log().bool_as_number();
+  hack::log()(true);
+  hack::log()(si);
+  hack::log()(usi);
+  hack::log().reset();
+  hack::log().set_devider(", ");
+  hack::log()(sti, 123, true);

  return 0;
 }
--- a/src/hack/concepts/concepts.hpp
+++ b/src/hack/concepts/concepts.hpp
@@ -3,8 +3,6 @@
 #include <vector>
 #include <list>
 #include <map>
-#include <set>
-#include <unordered_set>
 #include <unordered_map>
 #include <forward_list>
 #include <string_view>
@@ -91,16 +89,6 @@ namespace hack::concepts
                                  std::same_as<T, std::deque<typename T::value_type, typename T::allocator_type>> ||
                                  std::same_as<T, std::forward_list<typename T::value_type, typename T::allocator_type>>);

-  // Контейнеры с произвольным доступом
-  // @brief Проверяет, поддерживает ли контейнер произвольный доступ
-  // @details Обнаруживает контейнеры с оператором [] для быстрого доступа:
-  // - std::vector - O(1) доступ по индексу
-  // - std::deque - O(1) доступ по индексу
-  // - std::array - фиксированный массив с быстрым доступом
-  // Важно для алгоритмов, требующих частого доступа к элементам по индексу
-  template<typename T>
-  concept is_random_access_container = is_sequence_container<T> && requires(T t, std::size_t idx) { t[idx]; };
-
  // Адаптеры контейнеров
  // @brief Проверяет, является ли тип адаптером контейнера
  // @details Обнаруживает типы-обертки над другими контейнерами:
@@ -118,32 +106,24 @@ namespace hack::concepts
  // @details Обнаруживает контейнеры, хранящие элементы в отсортированном порядке:
  // - std::map - словарь с уникальными ключами
  // - std::multimap - словарь с возможностью дубликатов ключей
-  // - std::set - множество уникальных элементов
-  // - std::multiset - множество с возможностью дубликатов
  // Использует key_compare для упорядочивания (обычно std::less)
  template<typename T>
  concept is_associative_container = has_iterator<T> && 
                                     has_key_type<T> &&
                                    (has_mapped_type<T> || !has_mapped_type<T>) && // Для map и set
                                    (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::multimap<typename T::key_type, typename T::mapped_type, typename T::key_compare, typename T::allocator_type>> ||
-                                     std::same_as<T, std::set<typename T::key_type, typename T::key_compare, typename T::allocator_type>> ||
-                                     std::same_as<T, std::multiset<typename T::key_type, typename T::key_compare, typename T::allocator_type>>);
+                                     std::same_as<T, std::multimap<typename T::key_type, typename T::mapped_type, typename T::key_compare, typename T::allocator_type>>);

  // Неупорядоченные ассоциативные контейнеры
  // @brief Проверяет, является ли тип неупорядоченным ассоциативным контейнером
  // @details Обнаруживает контейнеры, использующие хеширование:
  // - std::unordered_map - хеш-таблица с уникальными ключами
  // - std::unordered_multimap - хеш-таблица с дубликатами ключей
-  // - std::unordered_set - хеш-множество уникальных элементов
-  // - std::unordered_multiset - хеш-множество с дубликатами
  // Используют хеш-функции и сравнение на равенство вместо упорядочивания
  template<typename T>
  concept is_unordered_associative_container = has_iterator<T> && has_key_type<T> && (has_mapped_type<T> || !has_mapped_type<T>) &&
                                              (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>> ||
-                                               std::same_as<T, std::unordered_multimap<typename T::key_type, typename T::mapped_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>> ||
-                                               std::same_as<T, std::unordered_set<typename T::key_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>> || 
-                                               std::same_as<T, std::unordered_multiset<typename T::key_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>>);
+                                               std::same_as<T, std::unordered_multimap<typename T::key_type, typename T::mapped_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>>);

  // Кортежи и пары
  // @brief Проверяет, является ли тип кортежоподобным
@@ -225,17 +205,6 @@ namespace hack::concepts
                            is_tuple_like<T> ||
                            std::is_pointer_v<T>);

-  // Вспомогательные концепты для метапрограммирования
-  // @brief Проверяет, имеет ли тип семантику ключ-значение
-  // @details Обнаруживает контейнеры, которые поддерживают доступ по ключу:
-  // - map и unordered_map (operator[])
-  // - set и unordered_set (хотя у set нет разделения на key/value)
-  // Полезно для алгоритмов работы со словарями и ассоциативными массивами
-  template<typename T>
-  concept has_key_value_semantics = is_associative_container<T> || 
-                                   is_unordered_associative_container<T> ||
-                                   requires(T t, typename T::key_type key) { t[key]; };
-
  // @brief Проверяет, является ли тип контейнером с непрерывной памятью
  // @details Обнаруживает контейнеры, элементы которых хранятся в непрерывной памяти:
  // - std::vector - динамический массив
@@ -268,15 +237,87 @@ namespace hack::concepts
  template<typename Container, typename Key>
  concept can_find = requires(Container c, Key&& key) { c.find(std::forward<Key>(key)); };

+  // @brief Проверяет, является ли тип bool
+  template<typename T>
+  concept is_bool = std::is_same_v<std::remove_cvref_t<T>, bool>;

  // @brief Проверяет, является ли данное числом
  // @details Проверяет на основные операции
  template<typename T>
  concept is_number = requires(T value) {
-    requires std::is_arithmetic_v<T>; // Включает все арифметические типы
+    requires std::is_arithmetic_v<T> && !is_bool<T>; // Включает все арифметические типы
    value + value; // Проверяет арифметические операции
    value - value;
    value * value;
    value / value;
  };
+
+  template<typename T>
+  concept is_set_like = requires {
+    // Общие требования для всех set-like контейнеров
+    typename T::key_type;
+    typename T::value_type;
+    requires std::is_same_v<typename T::key_type, typename T::value_type>; // key == value
+  } && requires(T t, typename T::key_type key) {
+    // Методы, характерные для set-like контейнеров
+    { t.begin() } -> std::same_as<typename T::iterator>;
+    { t.end() } -> std::same_as<typename T::iterator>;
+    { t.find(key) } -> std::same_as<typename T::iterator>;
+    { t.size() } -> std::convertible_to<std::size_t>;
+    { t.empty() } -> std::same_as<bool>;
+  };
+
+  // Базовый концепт для stack-like типов
+  template<typename T>
+  concept is_stack = requires(T s) {
+    typename T::value_type;
+    typename T::container_type;
+    { s.top() } -> std::same_as<typename T::value_type&>;
+    { s.pop() } -> std::same_as<void>;
+    { s.push(std::declval<typename T::value_type>()) } -> std::same_as<void>;
+    { s.empty() } -> std::same_as<bool>;
+    { s.size() } -> std::convertible_to<std::size_t>;
+  };
 }
+
+// namespace hack::concepts
+// {
+//   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 is_tuple = requires (T t) { std::tuple_cat(t, std::make_tuple(1, "tuple")); };
+//
+//   template<typename T>
+//   concept is_set = std::same_as<T, std::set<typename T::key_type, typename T::key_compare, typename T::allocator_type>>;
+//
+//   template<typename T>
+//   concept is_unordered_set = std::same_as<T, std::unordered_set<typename T::key_type>>;
+//
+//   template<typename T>
+//   concept is_forward_list = std::same_as<T, std::forward_list<typename T::value_type>>;
+//
+//   template<typename T>
+//   concept is_string = std::is_convertible_v<T, std::string_view>;
+//
+//   template<typename T, std::size_t N = 0>
+//   concept is_sequence_container = std::same_as<T, std::vector<typename T::value_type>> || std::same_as<T, std::list<typename T::value_type>> || (std::is_array_v<T> && N > 0);
+//
+//   template<typename T>
+//   concept is_associative_container = is_map<T> || is_tuple<T> || is_set<T> || is_unordered_set<T>;
+//
+//
+//   template<typename T>
+//   concept not_defined = !std::enable_if_t<!(std::integral<T> || 
+//                                             is_sequence_container<T> || 
+//                                             is_map<T> || 
+//                                             is_tuple<T> || 
+//                                             is_set<T> ||
+//                                             is_unordered_set<T> ||
+//                                             is_forward_list<T> ||
+//                                             std::is_array<T>() ||
+//                                             is_string<T>), bool>() ==  true;
+// }
+
+
--- a/src/hack/logger/logger.OLD.hpp
+++ b/src/hack/logger/logger.OLD.hpp
@@ -10,10 +10,6 @@

 #include "hack/patterns/ring_buffer.hpp"

-// HERE
-// и нужно сделать реализацию где выводлится все в одной линии но при помощи цикла
-// типа такого:
-// for (auto i : range) hack::log(hack::log::line)(i);
 namespace hack
 {
  class log
@@ -87,8 +83,6 @@ namespace hack
        std::cout << " }" << (count != 0 ? devider : "");
      }

-      // HERE
-      // реализовать это с учетом новых концептов
      template<concepts::is_set T>
      static void print_t(const T& data)
      {
@@ -127,12 +121,6 @@ namespace hack
        print_t(data, std::make_index_sequence<std::tuple_size<T>::value>{});
      }

-      template<concepts::not_defined T>
-      static void print_t(const T& data)
-      {
-        std::cout << data << (count != 0 ? devider : "");
-      }
-
      template<typename T, typename std::size_t... idx>
      static void print_t(const T& data, std::index_sequence<idx...>)
      {
@@ -141,6 +129,12 @@ namespace hack
        std::cout << " }" << (count != 0 ? devider : "");
      }

+      template<concepts::not_defined T>
+      static void print_t(const T& data)
+      {
+        std::cout << data << (count != 0 ? devider : "");
+      }
+
      template<typename T>
      static void print_t(const hack::patterns::ring_buffer<T>& rb)
      {
@@ -212,3 +206,4 @@ namespace hack
      }
  };
 }
+
--- a/src/hack/logger/logger.hpp
+++ b/src/hack/logger/logger.hpp
@@ -6,6 +6,9 @@
 #include "hack/utils/color.hpp"
 #include "hack/patterns/singleton.hpp"
 #include "hack/concepts/concepts.hpp"
+#include "hack/iterators/sequence_ostream_iterator.hpp"
+#include "hack/iterators/associative_ostream_iterator.hpp"
+#include <iterator>

 #include <execinfo.h>
 #include <iostream>
@@ -23,12 +26,19 @@ namespace hack
      void set_location(std::source_location location) { m_location = location; }
      void set_devider(std::string devider) { m_devider = devider; }
      void no_func() { m_no_func = true; };
+      void no_file() { m_no_file = true; }
+      void no_row() { m_no_row = true; }
+      void bool_as_number() { m_bool_as_number = true; }
      void reset() 
      { 
        m_no_func = m_base_config.m_no_func; 
        m_devider = m_base_config.m_devider;
+        m_no_file = m_base_config.m_no_file;
+        m_no_row = m_base_config.m_no_row;
+        m_bool_as_number = m_base_config.m_bool_as_number;
      }

+    public:
      template<typename... Args>
      void operator() (const Args&... args)
      {
@@ -38,23 +48,31 @@ namespace hack
      }

    private:
+      // настройки по умолчанию
      struct config
      {
-        bool m_no_func = false;
-        std::string m_devider = " ";
+        bool m_no_func = false; // показывать/не показывать название функции в выоде логов
+        bool m_no_file = false; // показывать/не показывать название файла/пути в выоде логов
+        bool m_no_row = false; // показывать/не показывать номер строки в выоде логов
+        bool m_bool_as_number = false; // показывет bool как число или как текст (0, false);
+        std::string m_devider = " "; // разделитель по умолчанию
      } m_base_config;

    private:
      void prepare()
      {
        std::stringstream ss;
-        ss << utils::color::bold << utils::color::green << "[ok]" << utils::color::reset << utils::color::green
-           << m_location.file_name() << ":" << utils::color::reset;
+        ss << utils::color::bold << utils::color::green << "[ok] " << utils::color::reset;
+
+        if (!m_no_file)
+          ss << utils::color::green << m_location.file_name() << ":" << utils::color::reset;

        if (!m_no_func)
          ss << utils::color::italic << utils::color::yellow << m_location.function_name() << utils::color::reset;

-        ss << utils::color::bold << utils::color::blue << "[" << m_location.line() << "]" << utils::color::reset << ": ";
+        if (!m_no_row)
+          ss << utils::color::bold << utils::color::blue << "[" << m_location.line() << "] " << utils::color::reset;
+
        std::cout << ss.str();
      }

@@ -62,33 +80,128 @@ namespace hack
      void print_impl(const T& data, const Args&... args)
      {
        --m_count;
-        pring_first(data);
+        print_t(data);
        print_impl(args...);
      }

      void print_impl() { std::cout << std::endl; }

-      template<typename T>
-      requires concepts::is_string<T>
-      void pring_first(const T& data)
+      // для строк
+      template<concepts::is_string T>
+      void print_t(const T& data)
      {
        std::cout << data << (m_count != 0 ? m_devider : "");
      }

-      template<typename T>
-      requires concepts::is_number<T>
-      void pring_first(const T& data)
+      // для всех чисел
+      template<concepts::is_number T>
+      void print_t(const T& data)
      {
        std::cout << data << (m_count != 0 ? m_devider : "");
      }
      
+      // для bool
+      template<concepts::is_bool T>
+      void print_t(const T& data)
+      {
+        if (!m_bool_as_number)
+          std::cout << (data ? "true" : "false") << (m_count != 0 ? m_devider : "");
+        else
+          std::cout << data << (m_count != 0 ? m_devider : "");
+      }
+
+      // для std::vector, std::list, std::forward_list, std::deque
+      template<concepts::is_sequence_container T>
+      void print_t(const T& data)
+      {
+        print_t<T, iterators::sequence_ostream_iterator>(data);
+      }
+
+      // для std::set и подобные
+      template<concepts::is_set_like T>
+      void print_t(const T& data)
+      {
+        print_t<T, iterators::sequence_ostream_iterator>(data);
+      }
+
+      // для std::map, std::multimap
+      template<concepts::is_associative_container T>
+      void print_t(const T& data)
+      {
+        print_t<T, iterators::associative_ostream_iterator>(data);
+      }
+
+      // для std::unordered_map
+      template<concepts::is_unordered_associative_container T>
+      void print_t(const T& data)
+      {
+        print_t<T, iterators::associative_ostream_iterator>(data);
+      }
+
+      // Вспомогательнгая функция для контейнеров выше
+      template<typename T, template<typename> class Iterator>
+      void print_t(const T& data)
+      {
+        std::cout << "{ ";
+
+        // Вычисляем размер для контейнеров, которые не имеют метода size()
+        std::size_t size = 0;
+        if constexpr (requires { data.size(); }) 
+          size = data.size();
+        else 
+          size = std::distance(data.cbegin(), data.cend());
+
+        std::copy(data.cbegin(), data.cend(), Iterator<typename T::value_type>(size, std::cout));
+        std::cout << " }" << (m_count != 0 ? m_devider : "");
+      }
+
+      // Основная функция для tuple
+      template<concepts::is_tuple_like T>
+      void print_t(const T& data)
+      {
+        std::cout << "{ ";
+        print_t(data, std::make_index_sequence<std::tuple_size_v<T>>{});
+        std::cout << " }" << (m_count != 0 ? m_devider : "");
+      }
+
+      template<typename T, std::size_t... idx>
+      void print_t(const T& data, std::index_sequence<idx...>)
+      {
+        ((std::cout << std::get<idx>(data) << (idx != std::tuple_size<T>::value - 1 ? m_devider : "")), ...);
+      }
+
+      // Для stack - выводим содержимое (но stack нельзя итерировать!)
+    template<concepts::is_stack T>
+    void print_t(const T& stack)
+    {
+      T temp = stack;
+      
+      std::cout << "{ ";
+      
+      bool first = true;
+      while (!temp.empty()) 
+      {
+        if (!first) 
+          std::cout << m_devider;
+        first = false;
+        std::cout << temp.top();
+        temp.pop();
+      }
+      
+      std::cout << " }" << (m_count != 0 ? m_devider : "");
+    }
+
    private:
      std::source_location m_location;
      std::size_t m_count = 0;
      std::string m_devider = m_base_config.m_devider;
      bool m_no_func = m_base_config.m_no_func;
+      bool m_no_file = m_base_config.m_no_file;
+      bool m_no_row = m_base_config.m_no_row;
+      bool m_bool_as_number = m_base_config.m_bool_as_number;
  };

+  // основная функция вызова логера
  inline logger& log(std::source_location location = std::source_location::current())
  {
    logger::instance().set_location(location);