thread/mtcore_thread/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_THREAD_TRAITS_HPP
#define MTCORE_THREAD_TRAITS_HPP
 
#include "mtcore/colls/optional.hpp"
#include "mtcore/colls/result.hpp"
#include "mtcore_thread/core.hpp"
#include <chrono>
#include <concepts>
 
namespace mtcore::thread {
  enum class SelectOptionErrors;
}
 
namespace mtcore::thread {
  template<typename T>
  concept SelectOption = requires(T &t, const T &ct) {
    { t.attempt() } -> std::same_as<Result<void, SelectOptionErrors>>;
    { ct.prevents_deadlock() } -> std::same_as<bool>;
  };

  template<typename T>
  concept Closeable = requires(T &t) {
    { t.close() } -> std::same_as<void>;
  };

  template<typename T>
  concept Sender = requires(T &t, const typename T::Message &m) {
    { t.try_send(m) } -> ResultLikeWithVoid;
  };

  template<typename T>
  concept Receiver = requires(T &t) {
    { t.try_receive() } -> ResultLikeWithValue<Optional<typename T::Message>>;
  };

  template<typename T>
  concept SenderBlock = requires(T &t) {
    { t.send_block({}) } -> ResultLikeWithVoid;
  };

  template<typename T>
  concept ReceiverBlock = requires(T &t) {
    { t.receive_block() } -> std::same_as<Optional<typename T::Message>>;
  };

  template<typename T>
  concept SenderBefore = requires(T &t, const std::chrono::time_point<std::chrono::system_clock> &sc) {
    { t.send_before({}, sc) } -> ResultLikeWithVoid;
  };

  template<typename T>
  concept ReceiverBefore = requires(T &t, const std::chrono::time_point<std::chrono::system_clock> &sc) {
    { t.receive_before(sc) } -> ResultLikeWithValue<Optional<typename T::Message>>;
  };

  template<typename T>
  concept SenderGrow = requires(T &t, Allocator &a) {
    { t.try_send(a, {}) } -> ResultLikeWithVoid;
  } && Sender<T>;

  template<typename T>
  concept SenderBlockGrow = requires(T &t, Allocator &a) {
    { t.send_block(a, {}) } -> ResultLikeWithVoid;
  } && SenderBlock<T>;

  template<typename T>
  concept SenderBeforeGrow =
    requires(T &t, const std::chrono::time_point<std::chrono::system_clock> &sc, Allocator &a) {
      { t.send_before(a, {}, sc) } -> ResultLikeWithVoid;
    } && SenderBefore<T>;

  template<typename T>
  concept HasClosedError = requires {
    { T::CHANNEL_CLOSED };
  };
 
#define MTCORE_THREAD_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 {};                                                                           \
  }

  template<typename T>
  concept SenderReceiver = Sender<T> && Receiver<T>;

  template<typename T>
  concept SenderReceiverBlock = SenderBlock<T> && ReceiverBlock<T>;

  template<typename T>
  concept SenderReceiverBefore = SenderBefore<T> && ReceiverBefore<T>;

  template<typename T>
  concept SenderReceiverGrow = SenderGrow<T> && ReceiverBefore<T>;

  template<typename T>
  concept SenderReceiverBlockGrow = SenderBlockGrow<T> && ReceiverBefore<T>;

  template<typename T>
  concept SenderReceiverBeforeGrow = SenderBeforeGrow<T> && ReceiverBefore<T>;

  template<typename T>
  concept ChannelLike = SenderReceiver<T> && SenderReceiverBlock<T> && SenderReceiverBefore<T> && Closeable<T>;

  template<typename T>
  concept ChannelLikeGrow =
    ChannelLike<T> && SenderReceiverGrow<T> && SenderReceiverBlockGrow<T> && SenderReceiverBeforeGrow<T>;
 
  MTCORE_THREAD_TRAIT_ISA(Sender);
  MTCORE_THREAD_TRAIT_ISA(SenderGrow);
  MTCORE_THREAD_TRAIT_ISA(SenderBlock);
  MTCORE_THREAD_TRAIT_ISA(SenderBlockGrow);
  MTCORE_THREAD_TRAIT_ISA(SenderBefore);
  MTCORE_THREAD_TRAIT_ISA(SenderBeforeGrow);
  MTCORE_THREAD_TRAIT_ISA(Receiver);
  MTCORE_THREAD_TRAIT_ISA(ReceiverBlock);
  MTCORE_THREAD_TRAIT_ISA(ReceiverBefore);
  MTCORE_THREAD_TRAIT_ISA(Closeable);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiver);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiverBlock);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiverBefore);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiverGrow);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiverBlockGrow);
  MTCORE_THREAD_TRAIT_ISA(SenderReceiverBeforeGrow);
  MTCORE_THREAD_TRAIT_ISA(ChannelLike);
  MTCORE_THREAD_TRAIT_ISA(ChannelLikeGrow);
  MTCORE_THREAD_TRAIT_ISA(SelectOption);
  MTCORE_THREAD_TRAIT_ISA(HasClosedError);

  template<typename T>
  constexpr bool has_closed_error = impl::IsHasClosedError<T>::value;

  template<typename T>
  constexpr bool is_closeable = impl::IsCloseable<T>::value;

  template<typename T>
  constexpr bool is_sender = impl::IsSender<T>::value;

  template<typename T>
  constexpr bool is_sender_grow = impl::IsSenderGrow<T>::value;

  template<typename T>
  constexpr bool is_sender_block = impl::IsSenderBlock<T>::value;

  template<typename T>
  constexpr bool is_sender_block_grow = impl::IsSenderBlockGrow<T>::value;

  template<typename T>
  constexpr bool is_sender_before = impl::IsSenderBefore<T>::value;

  template<typename T>
  constexpr bool is_sender_before_grow = impl::IsSenderBeforeGrow<T>::value;

  template<typename T>
  constexpr bool is_receiver = impl::IsReceiver<T>::value;

  template<typename T>
  constexpr bool is_receiver_block = impl::IsReceiverBlock<T>::value;

  template<typename T>
  constexpr bool is_receiver_before = impl::IsReceiverBefore<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver = impl::IsSenderReceiver<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver_grow = impl::IsSenderReceiverGrow<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver_block = impl::IsSenderReceiverBlock<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver_block_grow = impl::IsSenderReceiverBlockGrow<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver_before = impl::IsSenderReceiverBefore<T>::value;

  template<typename T>
  constexpr bool is_sender_receiver_before_grow = impl::IsSenderReceiverBeforeGrow<T>::value;

  template<typename T>
  constexpr bool is_channel_like = impl::IsChannelLike<T>::value;

  template<typename T>
  constexpr bool is_channel_like_grow = impl::IsChannelLikeGrow<T>::value;

  template<typename T>
  constexpr bool is_select_option = impl::IsSelectOption<T>::value;
}  // namespace mtcore::thread
 
#endif  // MTCORE_THREAD_TRAITS_HPP