core/mtcore/traits.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_TRAITS_HPP
#define MTCORE_TRAITS_HPP
 
#include <concepts>
#include <ostream>


namespace mtcore {
  template<typename T>
  struct Slice;
 
  template<typename T>
  struct Optional;
  struct Allocator;
 
  namespace io {
    struct FormatOptions;
    template<typename T>
    struct Formatter;
    namespace impl {
      template<typename T>
      struct VoidWriterImpl;
    }
  }  // namespace io

  template<typename T>
  concept Ostreamable = requires(const T &c, std::ostream &os) {
    { os << c };
  };

  template<typename T>
  concept Addressable = requires(const T &c) {
    { c.size() } -> std::convertible_to<size_t>;
    { c.at(0) } -> std::convertible_to<const typename T::Elem &>;
    { c[0] } -> std::convertible_to<const typename T::Elem &>;
  };

  template<typename T>
  concept MutableAddressable = requires(T &t) {
    { t.size() } -> std::convertible_to<size_t>;
    { t.at(0) } -> std::same_as<typename T::Elem &>;
    { t[0] } -> std::same_as<typename T::Elem &>;
  } && Addressable<T>;

  template<typename T>
  concept Iterator = requires(T &t) {
    { t.next() } -> std::same_as<Optional<typename T::IterElem>>;
  };
 
  template<typename T, typename... Args>
  concept Initable = requires(T &t, Args... args) {
    { t.init(args...) };
  };

  template<typename T>
  concept Iterable = requires(const T &t) {
    { t.iter() } -> Iterator;
  };

  template<typename T>
  concept StdIterable = requires(const T &t) {
    std::begin(t) != std::end(t);
    ++std::declval<decltype(std::begin(t)) &>();
    *std::begin(t);
  };

  template<typename T>
  concept DefaultDeinit = requires(T &t) { t.deinit(); };

  template<typename T>
  concept AllocatorDeinit = requires(T &t, Allocator &alloc) { t.deinit(alloc); };
 
  namespace impl {
    template<typename T>
    concept ResultVoid = requires() {
      { T::from_success() } -> std::same_as<T>;
    };
 
    template<typename T>
    concept ResultValue =
      requires(T &t, const T &c, const typename T::Value &v, std::remove_const_t<typename T::Value> &vo) {
        { T::from_success(v) } -> std::same_as<T>;
        { c.copy_if_present(vo) } -> std::same_as<bool>;
        { t.move_if_present(vo) } -> std::same_as<bool>;
        { c.value() } -> std::same_as<typename T::Value>;
        { *c };
      };
  }  // namespace impl

  template<typename T>
  concept ResultLike = requires(T &t, const T &c, typename T::ErrVal e) {
    { T::from_error(e) } -> std::same_as<T>;
    { t == c } -> std::same_as<bool>;
    { c != t } -> std::same_as<bool>;
    { c.is_error() } -> std::same_as<bool>;
    { c.is_success() } -> std::same_as<bool>;
    { c.error() } -> std::same_as<typename T::ErrVal>;
  } && (impl::ResultVoid<T> || impl::ResultValue<T>);

  template<typename T, typename V>
  concept ResultLikeWithValue =
    ((impl::ResultVoid<T> && std::same_as<V, void>) || (impl::ResultValue<T> && std::same_as<typename T::Value, V>) ) &&
    ResultLike<T>;

  template<typename T>
  concept ResultLikeWithVoid = ResultLikeWithValue<T, void>;

  template<typename T>
  concept WriterImpl = requires(T &t, const Slice<std::add_const_t<typename T::WriteElem>> &ws) {
    { t.write(ws) } -> ResultLikeWithValue<size_t>;
    // This value should NOT be returned from write
    // It is only used by the writer wrapper to indicate a write was partial
    { T::ErrType::OUT_OF_ROOM };
  };

  template<typename T>
  concept WriterImplBytes = requires(const T &ct) {
    { ct.bytes_written() } -> std::same_as<size_t>;
  };

  template<typename T>
  concept WriterImplWritten = requires(const T &ct) {
    { ct.written() };
  };

  template<typename T>
  concept WriterImplResettable = requires(T &t) {
    { t.reset() };
  };
 
  template<typename T>
  concept Pointer = std::is_pointer_v<T>;

  template<typename T>
  concept WriteThrough = requires {
    { T::IsWriteThrough };
  } && WriterImpl<T>;

  template<typename T>
  concept Flushable = requires(T &t) {
    { t.flush() } -> ResultLikeWithVoid;
  };
 
  namespace io {
    template<WriterImpl T>
    struct Writer;
  }

  template<typename T>
  concept ReaderImpl = requires(T &t, size_t s, Slice<std::remove_const_t<typename T::ReadElem>> outBuff) {
    { t.read(outBuff) } -> ResultLikeWithValue<Slice<std::add_const_t<typename T::ReadElem>>>;
    // This value should NOT be returned from write
    // It is only used by the writer wrapper to indicate a write was partial
    { T::ErrType::END_OF_FILE };
    { T::ErrType::ALLOCATION_FAILED };
    { T::ErrType::SIZE_EXCEEDED };
  };
 
  template<typename T>
  concept InlineFormattable =
    requires(const T &t, io::Writer<io::impl::VoidWriterImpl<T>> &wi, const io::FormatOptions &opts) {
      { t.format(wi, opts) } -> ResultLikeWithValue<size_t>;
    };

  template<typename T>
  concept Formattable = requires(const T &t, io::Writer<io::impl::VoidWriterImpl<T>> &wi,
                                 const io::FormatOptions &opts) { mtcore::io::Formatter<T>::fmt(wi, opts, t); };

  template<typename T>
  concept DefaultFormattable =
    Formattable<T> && !StdIterable<T> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, char> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, i8> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, i16> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, i32> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, i64> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, u8> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, u16> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, u32> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, u64> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, f32> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, f64> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, f80> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, char8_t> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, char16_t> &&
    !std::same_as<std::remove_cvref_t<std::remove_pointer_t<std::remove_cvref_t<std::decay_t<T>>>>, char32_t>;
 
  namespace impl {
    template<typename V, typename T>
    struct IsResultWithValue;
    template<typename V, ResultLikeWithValue<V> T>
    struct IsResultWithValue<V, T> : std::true_type {};
    template<typename V, typename T>
    struct IsResultWithValue : std::false_type {};
 
    template<typename... Args>
    struct IsInitable;
    template<typename... Args, Initable<Args...> T>
    struct IsInitable<T, Args...> : std::true_type {};
    template<typename... Args>
    struct IsInitable : std::false_type {};
  }  // namespace impl
 
#define MTCORE_TRAIT_ISA(Concept)                                                                                      \
  namespace impl {                                                                                                     \
    template<typename T>                                                                                               \
    struct Is##Concept;                                                                                                \
    template<Concept T>                                                                                                \
    struct Is##Concept<T> : std::true_type {};                                                                         \
    template<typename T>                                                                                               \
    struct Is##Concept : std::false_type {};                                                                           \
  }
 
  MTCORE_TRAIT_ISA(Formattable)
 
  MTCORE_TRAIT_ISA(Addressable)
 
  MTCORE_TRAIT_ISA(MutableAddressable)
 
  MTCORE_TRAIT_ISA(Iterator)
 
  MTCORE_TRAIT_ISA(DefaultDeinit)
 
  MTCORE_TRAIT_ISA(AllocatorDeinit)
 
  MTCORE_TRAIT_ISA(Ostreamable)
 
  MTCORE_TRAIT_ISA(Flushable)
 
  MTCORE_TRAIT_ISA(WriteThrough)
 
  
  template<typename T, typename V>
  constexpr bool is_result_with_value = impl::IsResultWithValue<V, T>::value;

  template<typename T>
  constexpr bool is_write_through = impl::IsWriteThrough<T>::value;

  template<typename T>
  constexpr bool is_result_void = impl::IsResultWithValue<void, T>::value;

  template<typename T>
  constexpr bool is_addressable = impl::IsAddressable<T>::value;

  template<typename T>
  constexpr bool is_mutable_addressable = impl::IsAddressable<T>::value;

  template<typename T>
  constexpr bool is_ostreamable = impl::IsOstreamable<T>::value;

  template<typename T>
  constexpr bool is_iterator = impl::IsIterator<T>::value;

  template<typename T>
  constexpr bool is_flushable = impl::IsFlushable<T>::value;

  template<typename T>
  constexpr bool is_allocator_deinit = impl::IsAllocatorDeinit<T>::value;

  template<typename T, typename... Args>
  constexpr bool is_initable = impl::IsInitable<T, Args...>::value;

  template<typename T>
  constexpr bool is_formattable = impl::IsFormattable<T>::value;

  template<typename T>
  constexpr bool is_default_deinit = impl::IsDefaultDeinit<T>::value;
}  // namespace mtcore
 
#endif  // MTCORE_TRAITS_HPP