chatlanin/hack
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add primary container and concepts for logger

Browse Source
This commit is contained in:
Андрей Зимин
2025-09-10 00:10:30 +03:00
parent 86d4535401
commit 057dc595ac
5 changed files with 246 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
src/hack/concepts/concepts.hpp
View File

@@ -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;
// }

21
src/hack/logger/logger.OLD.hpp Executable file → Normal file
View File

@@ -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)
{
@@ -112,7 +106,7 @@ namespace hack
std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(std::distance(data.cbegin(), data.cend()), std::cout));
std::cout << " }" << (count != 0 ? devider : "");
}
template<concepts::is_map 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
}
};
}

137
src/hack/logger/logger.hpp
View File

@@ -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);