concepts.hpp

#ifndef RFL_CONCEPTS_HPP_
#define RFL_CONCEPTS_HPP_

#include <concepts>
#include <type_traits>
#include <cstdint>
#include <cstddef>
#include <iterator>

namespace rfl {

/// @brief Concept for byte-like types that can be used in contiguous containers
/// Includes char, signed char, unsigned char, std::byte, and uint8_t
template<typename T>
concept ByteLike = std::same_as<T, char> ||
                   std::same_as<T, signed char> ||
                   std::same_as<T, unsigned char> ||
                   std::same_as<T, std::uint8_t> ||
                   std::same_as<T, std::byte>;

/// @brief Concept for containers with a contiguous sequence of byte-like types
/// Requires:
/// - Container has a value_type that is byte-like
/// - Container provides data() method returning a pointer to contiguous memory
/// - Container provides size() method returning the number of elements
/// - Container supports range-based for loops (begin/end)
template<typename Container>
concept ContiguousByteContainer = requires(const Container& c) {
    typename Container::value_type;
    { c.data() } -> std::convertible_to<const typename Container::value_type*>;
    { c.size() } -> std::convertible_to<std::size_t>;
    { c.begin() } -> std::input_iterator;
    { c.end() } -> std::input_iterator;
    requires ByteLike<typename Container::value_type>;
    requires std::contiguous_iterator<decltype(c.begin())>;
};

/// @brief Concept for mutable containers with a contiguous sequence of byte-like types
/// Extends ContiguousByteContainer with mutable access requirements
template<typename Container>
concept MutableContiguousByteContainer = ContiguousByteContainer<Container> && requires(Container& c) {
    { c.data() } -> std::convertible_to<typename Container::value_type*>;
    { c.begin() } -> std::output_iterator<typename Container::value_type>;
    { c.end() } -> std::output_iterator<typename Container::value_type>;
};

/// @brief Concept for back-insertable byte containers (like std::vector<uint8_t>)
/// Useful for containers that can grow dynamically during serialization
template<typename Container>
concept BackInsertableByteContainer = ContiguousByteContainer<Container> && requires(Container& c, typename Container::value_type v) {
    c.push_back(v);
    c.reserve(std::size_t{});
    { c.capacity() } -> std::convertible_to<std::size_t>;
};

/// @brief Concept for byte spans or views (read-only, non-owning containers)
/// Includes std::span<const uint8_t>, std::string_view when used with char data, etc.
template<typename Container>
concept ByteSpanLike = ContiguousByteContainer<Container> &&
                      std::is_trivially_copyable_v<Container> &&
                      std::is_trivially_destructible_v<Container>;

} // namespace rfl

#endif // RFL_CONCEPTS_HPP_