execution overhaul

bench/bench.cpp

@@ -42,7 +42,7 @@ class test_context : public execution_context
 // Test Executor
 //
 // A minimal executor that satisfies the capy
-// dispatcher concept. Dispatches inline for
+// Executor concept. Dispatches inline for
 // benchmarking pure coroutine overhead.
 //
 //-----------------------------------------------
@@ -75,8 +75,8 @@ class test_executor
     {
     }
 
-    // Dispatcher interface - dispatch inline
-    any_coro operator()(any_coro h) const
+    // Executor interface - dispatch inline
+    any_coro dispatch(any_coro h) const
     {
         return h;
     }

include/boost/capy.hpp

@@ -10,7 +10,7 @@
 #ifndef BOOST_CAPY_HPP
 #define BOOST_CAPY_HPP
 
-#include <boost/capy/ex/any_dispatcher.hpp>
+#include <boost/capy/ex/any_executor_ref.hpp>
 #include <boost/capy/application.hpp>
 #include <boost/capy/ex/async_op.hpp>
 #include <boost/capy/ex/run_async.hpp>
@@ -34,14 +34,12 @@
 #include <boost/capy/buffers/slice.hpp>
 #include <boost/capy/buffers/string_buffer.hpp>
 #include <boost/capy/buffers/to_string.hpp>
-#include <boost/capy/concept/affine_awaitable.hpp>
 #include <boost/capy/concept/data_source.hpp>
-#include <boost/capy/concept/dispatcher.hpp>
 #include <boost/capy/concept/dynamic_buffer.hpp>
 #include <boost/capy/concept/executor.hpp>
 #include <boost/capy/concept/frame_allocator.hpp>
+#include <boost/capy/concept/io_awaitable.hpp>
 #include <boost/capy/concept/read_stream.hpp>
-#include <boost/capy/concept/stoppable_awaitable.hpp>
 #include <boost/capy/detail/config.hpp>
 #include <boost/capy/ex/any_coro.hpp>
 #include <boost/capy/datastore.hpp>

include/boost/capy/buffers.hpp

@@ -325,24 +325,24 @@ class const_buffer
 
 /** Concept for types that model ConstBufferSequence.
 
-    A type satisfies `const_buffer_sequence` if it is convertible
+    A type satisfies `ConstBufferSequence` if it is convertible
     to `const_buffer`, or if it is a bidirectional range whose
     value type is convertible to `const_buffer`.
 */
 template<typename T>
-concept const_buffer_sequence =
+concept ConstBufferSequence =
     std::is_convertible_v<T, const_buffer> || (
         std::ranges::bidirectional_range<T> &&
         std::is_convertible_v<std::ranges::range_value_t<T>, const_buffer>);
 
 /** Concept for types that model MutableBufferSequence.
 
-    A type satisfies `mutable_buffer_sequence` if it is convertible
+    A type satisfies `MutableBufferSequence` if it is convertible
     to `mutable_buffer`, or if it is a bidirectional range whose
     value type is convertible to `mutable_buffer`.
 */
 template<typename T>
-concept mutable_buffer_sequence =
+concept MutableBufferSequence =
     std::is_convertible_v<T, mutable_buffer> || (
         std::ranges::bidirectional_range<T> &&
         std::is_convertible_v<std::ranges::range_value_t<T>, mutable_buffer>);
@@ -369,16 +369,16 @@ constexpr struct begin_mrdocs_workaround_t
         return std::addressof(b);
     }
 
-    template<const_buffer_sequence BufferSequence>
-        requires (!std::convertible_to<BufferSequence, const_buffer>)
-    auto operator()(BufferSequence const& bs) const noexcept
+    template<ConstBufferSequence BS>
+        requires (!std::convertible_to<BS, const_buffer>)
+    auto operator()(BS const& bs) const noexcept
     {
         return std::ranges::begin(bs);
     }
 
-    template<const_buffer_sequence BufferSequence>
-        requires (!std::convertible_to<BufferSequence, const_buffer>)
-    auto operator()(BufferSequence& bs) const noexcept
+    template<ConstBufferSequence BS>
+        requires (!std::convertible_to<BS, const_buffer>)
+    auto operator()(BS& bs) const noexcept
     {
         return std::ranges::begin(bs);
     }
@@ -406,28 +406,28 @@ constexpr struct end_mrdocs_workaround_t
         return std::addressof(b) + 1;
     }
 
-    template<const_buffer_sequence BufferSequence>
-        requires (!std::convertible_to<BufferSequence, const_buffer>)
-    auto operator()(BufferSequence const& bs) const noexcept
+    template<ConstBufferSequence BS>
+        requires (!std::convertible_to<BS, const_buffer>)
+    auto operator()(BS const& bs) const noexcept
     {
         return std::ranges::end(bs);
     }
 
-    template<const_buffer_sequence BufferSequence>
-        requires (!std::convertible_to<BufferSequence, const_buffer>)
-    auto operator()(BufferSequence& bs) const noexcept
+    template<ConstBufferSequence BS>
+        requires (!std::convertible_to<BS, const_buffer>)
+    auto operator()(BS& bs) const noexcept
     {
         return std::ranges::end(bs);
     }
 } end {};
 
 //------------------------------------------------------------------------------
 
-template<const_buffer_sequence ConstBufferSequence>
+template<ConstBufferSequence CB>
 std::size_t
 tag_invoke(
     size_tag const&,
-    ConstBufferSequence const& bs) noexcept
+    CB const& bs) noexcept
 {
     std::size_t n = 0;
     auto const e = end(bs);
@@ -446,23 +446,23 @@ tag_invoke(
 
     @par Constraints
     @code
-    const_buffer_sequence<T>
+    ConstBufferSequence<T>
     @endcode
 
     @par Example
     @code
-    template<const_buffer_sequence ConstBufferSequence>
-    bool is_small( ConstBufferSequence const& bs ) noexcept
+    template<ConstBufferSequence CB>
+    bool is_small( CB const& bs ) noexcept
     {
         return buffer_size(bs) < 100;
     }
     @endcode
 */
 constexpr struct buffer_size_mrdocs_workaround_t
 {
-    template<const_buffer_sequence ConstBufferSequence>
+    template<ConstBufferSequence CB>
     constexpr std::size_t operator()(
-        ConstBufferSequence const& bs) const noexcept
+        CB const& bs) const noexcept
     {
         return tag_invoke(size_tag{}, bs);
     }
@@ -497,19 +497,19 @@ length_impl(It first, It last, long)
 
 /** Return the number of elements in a buffer sequence.
 */
-template<const_buffer_sequence ConstBufferSequence>
+template<ConstBufferSequence CB>
 std::size_t
-buffer_length(ConstBufferSequence const& bs)
+buffer_length(CB const& bs)
 {
     return detail::length_impl(
         begin(bs), end(bs), 0);
 }
 
 /** Alias for const_buffer or mutable_buffer depending on sequence type.
 */
-template<typename BufferSequence>
+template<typename BS>
 using buffer_type = std::conditional_t<
-    mutable_buffer_sequence<BufferSequence>,
+    MutableBufferSequence<BS>,
     mutable_buffer, const_buffer>;
 
 } // capy

include/boost/capy/buffers/copy.hpp

@@ -25,8 +25,8 @@ namespace capy {
 
     @par Constraints
     @code
-    mutable_buffer_sequence<decltype(dest)> &&
-    const_buffer_sequence<decltype(src)>
+    MutableBufferSequence<decltype(dest)> &&
+    ConstBufferSequence<decltype(src)>
     @endcode
 
     @return The number of bytes actually copied, which will be exactly equal to
@@ -39,8 +39,8 @@ namespace capy {
 constexpr struct copy_mrdocs_workaround_t
 {
     template<
-        mutable_buffer_sequence MutableBufferSequence,
-        const_buffer_sequence ConstBufferSequence>
+        MutableBufferSequence MutableBufferSequence,
+        ConstBufferSequence ConstBufferSequence>
     std::size_t
     operator()(
         MutableBufferSequence const& dest,

include/boost/capy/buffers/data_source.hpp

@@ -22,7 +22,7 @@ namespace capy {
 */
 template<class T>
 struct is_data_source
-    : std::bool_constant<data_source<T>>
+    : std::bool_constant<DataSource<T>>
 {
 };
 

include/boost/capy/buffers/dynamic_buffer.hpp

@@ -22,20 +22,20 @@ namespace capy {
 /** Metafunction to detect if a type is a dynamic buffer.
 */
 template<class T>
-struct is_dynamic_buffer
-    : std::bool_constant<dynamic_buffer<T>>
+struct is_DynamicBuffer
+    : std::bool_constant<DynamicBuffer<T>>
 {
 };
 
 /** An abstract, type-erased dynamic buffer.
 */
 struct BOOST_SYMBOL_VISIBLE
-    any_dynamic_buffer
+    any_DynamicBuffer
 {
     using const_buffers_type = span<const_buffer const>;
     using mutable_buffers_type = span<mutable_buffer const>;
 
-    virtual ~any_dynamic_buffer() = default;
+    virtual ~any_DynamicBuffer() = default;
     virtual std::size_t size() const = 0;
     virtual std::size_t max_size() const = 0;
     virtual std::size_t capacity() const = 0;
@@ -50,18 +50,18 @@ struct BOOST_SYMBOL_VISIBLE
 /** A type-erased dynamic buffer.
 */
 template<
-    dynamic_buffer DynamicBuffer,
+    DynamicBuffer DynamicBuffer,
     std::size_t N = 8>
-class any_dynamic_buffer_impl
-    : public any_dynamic_buffer
+class any_DynamicBuffer_impl
+    : public any_DynamicBuffer
 {
     DynamicBuffer b_;
     const_buffer data_[N];
     mutable_buffer out_[N];
     std::size_t data_len_ = 0;
     std::size_t out_len_ = 0;
 
-    template<const_buffer_sequence ConstBufferSequence, class BufferType>
+    template<ConstBufferSequence ConstBufferSequence, class BufferType>
     static
     std::size_t
     unroll(
@@ -83,7 +83,7 @@ class any_dynamic_buffer_impl
 public:
     template<class DynamicBuffer_>
     explicit
-    any_dynamic_buffer_impl(
+    any_DynamicBuffer_impl(
         DynamicBuffer_&& b)
         : b_(std::forward<DynamicBuffer_>(b))
     {
@@ -156,12 +156,12 @@ class any_dynamic_buffer_impl
     }
 };
 
-template<dynamic_buffer DynamicBuffer>
+template<DynamicBuffer DynamicBuffer>
 auto
 make_any(DynamicBuffer&& b) ->
-    any_dynamic_buffer_impl<std::decay_t<DynamicBuffer>>
+    any_DynamicBuffer_impl<std::decay_t<DynamicBuffer>>
 {
-    return any_dynamic_buffer_impl<std::decay_t<DynamicBuffer>>(
+    return any_DynamicBuffer_impl<std::decay_t<DynamicBuffer>>(
             std::forward<DynamicBuffer>(b));
 }
 

include/boost/capy/buffers/front.hpp

@@ -21,7 +21,7 @@ namespace capy {
 */
 constexpr struct front_mrdocs_workaround_t
 {
-    template<mutable_buffer_sequence MutableBufferSequence>
+    template<MutableBufferSequence MutableBufferSequence>
     mutable_buffer
     operator()(
         MutableBufferSequence const& bs) const noexcept
@@ -32,8 +32,8 @@ constexpr struct front_mrdocs_workaround_t
         return {};
     }
 
-    template<const_buffer_sequence ConstBufferSequence>
-        requires (!mutable_buffer_sequence<ConstBufferSequence>)
+    template<ConstBufferSequence ConstBufferSequence>
+        requires (!MutableBufferSequence<ConstBufferSequence>)
     const_buffer
     operator()(
         ConstBufferSequence const& bs) const noexcept

include/boost/capy/buffers/sink.hpp

@@ -23,10 +23,10 @@ struct buffer_sink
 {
     void size_hint( std::size_t size );
 
-    struct mutable_buffer_sequence;
+    struct MutableBufferSequence;
 
     auto prepare( std::size_t size )
-      -> mutable_buffer_sequence;
+      -> MutableBufferSequence;
 
     auto commit(
         std::size_t n,