container.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <concepts>
#include <type_traits>
#include <iterator>
 
namespace kcenon::common {
namespace concepts {
 
template<typename T>
concept Container = requires(T t) {
    typename T::value_type;
    typename T::iterator;
    typename T::const_iterator;
    { t.begin() } -> std::input_or_output_iterator;
    { t.end() } -> std::input_or_output_iterator;
    { t.size() } -> std::convertible_to<std::size_t>;
    { t.empty() } -> std::convertible_to<bool>;
};
 
template<typename T>
concept SequenceContainer = Container<T> && requires(T t, typename T::value_type v) {
    { t.push_back(v) };
    { t.front() } -> std::same_as<typename T::value_type&>;
    { t.back() } -> std::same_as<typename T::value_type&>;
};
 
template<typename T>
concept AssociativeContainer = Container<T> && requires(T t) {
    typename T::key_type;
    { t.find(std::declval<typename T::key_type>()) } -> std::same_as<typename T::iterator>;
    { t.count(std::declval<typename T::key_type>()) } -> std::convertible_to<std::size_t>;
};
 
template<typename T>
concept MappingContainer = AssociativeContainer<T> && requires {
    typename T::mapped_type;
};
 
template<typename T>
concept ResizableContainer = Container<T> && requires(T t, std::size_t n) {
    { t.resize(n) };
    { t.reserve(n) };
    { t.capacity() } -> std::convertible_to<std::size_t>;
};
 
template<typename T>
concept ClearableContainer = Container<T> && requires(T t) {
    { t.clear() };
};
 
template<typename T>
concept InsertableContainer = Container<T> && requires(T t, typename T::iterator it, typename T::value_type v) {
    { t.insert(it, v) } -> std::same_as<typename T::iterator>;
};
 
template<typename T>
concept ErasableContainer = Container<T> && requires(T t, typename T::iterator it) {
    { t.erase(it) } -> std::same_as<typename T::iterator>;
};
 
template<typename T>
concept RandomAccessContainer = Container<T> && requires(T t, std::size_t i) {
    { t[i] } -> std::same_as<typename T::value_type&>;
};
 
template<typename T>
concept BoundedContainer = Container<T> && requires(const T t) {
    { t.max_size() } -> std::convertible_to<std::size_t>;
};
 
template<typename T>
concept ThreadSafeContainer = Container<T> && requires(T t) {
    { t.lock() };
};
 
template<typename T>
concept PoolableContainer = requires(T t) {
    { t.acquire() };
    { t.release(std::declval<decltype(t.acquire())>()) };
    { t.available_count() } -> std::convertible_to<std::size_t>;
};
 
template<typename T>
concept CircularBuffer = Container<T> && requires(const T t) {
    { t.full() } -> std::convertible_to<bool>;
    { t.capacity() } -> std::convertible_to<std::size_t>;
};
 
} // namespace concepts
} // namespace kcenon::common