Remove obsolete route results and trim old APIs

Author: vinniefalco

include/boost/http/server/route_handler.hpp

@@ -20,7 +20,6 @@
 #include <boost/http/serializer.hpp>      // VFALCO forward declare?
 #include <boost/url/url_view.hpp>
 #include <boost/system/error_code.hpp>
-#include <functional>
 #include <memory>
 
 namespace boost {
@@ -75,16 +74,6 @@ struct BOOST_HTTP_SYMBOL_VISIBLE
     */
     capy::datastore session_data;
 
-    /** The suspender for this session.
-
-        This can be used to suepend from the router and resume routing later.
-    */
-    suspender suspend;
-
-    /** Executor associated with the session.
-    */
-    capy::any_executor_ref ex;
-
     /** Destructor
     */
     BOOST_HTTP_DECL
@@ -114,161 +103,9 @@ struct BOOST_HTTP_SYMBOL_VISIBLE
     route_params&
     set_body(std::string s);
 
-    /** Read the request body and receive a value.
-
-        This function reads the entire request body into the specified sink.
-        When the read operation completes, the given callback is invoked with
-        the result.
-
-        The @p callback parameter must be a function object with this
-        equivalent signature, where `T` is the type produced by the value sink:
-        @code
-        void ( T&& t );
-        @endcode
-
-        @par Example
-        @code
-        rp.read_body(
-            capy::string_body_sink(),
-            []( std::string s )
-            {
-                // body read successfully
-            });
-        @endcode
-
-        If an error or an exception occurs during the read, it is propagated
-        through the router to the next error or exception handler.
-
-        @param sink The body sink to read into.
-        @param callback The function to call when the read completes.
-        @return The route result, which must be returned immediately
-            from the route handler.
-    */
-    template<
-        class ValueSink,
-        class Callback>
-    auto
-    read_body(
-        ValueSink&& sink,
-        Callback&& callback) ->
-            route_result;
-
-#ifdef BOOST_HTTP_HAS_CORO
-
-    /** Spawn a coroutine for this route.
-
-        This function is used to spawn a coroutine
-        for the route handler. The coroutine is
-        passed a reference to the route_params object,
-        and when it returns, the returned route_result
-        is returned from this function.
-
-        @par Example
-        @code
-        auto handler =
-            []( route_params& rp ) -> route_result
-            {
-                return rp.spawn(
-                    []( route_params& rp ) -> capy::task<route_result>
-                    {
-                        co_return route_result::next;
-                    });
-            };
-        @endcode
-        @param coro The coroutine to spawn.
-        @return The route result, which must be returned immediately
-            from the route handler.
-    */
-    BOOST_HTTP_DECL
-    auto spawn(
-        capy::task<route_result> coro) ->
-            route_result;
-
-#endif
-
-protected:
-    std::function<void(void)> finish_;
+    //http::route_task capy::task<http::route_result>
 };
 
-//-----------------------------------------------
-
-template<
-    class ValueSink,
-    class Callback>
-auto
-route_params::
-read_body(
-    ValueSink&& sink,
-    Callback&& callback) ->
-        route_result
-{
-    using T = typename std::decay<ValueSink>::type;
-
-    struct on_finish
-    {
-        T& sink;
-        resumer resume;
-        typename std::decay<Callback>::type cb;
-
-        on_finish(
-            T& sink_,
-            resumer resume_,
-            Callback&& cb_) 
-            : sink(sink_)
-            , resume(resume_)
-            , cb(std::forward<Callback>(cb_))
-        {
-        }
-
-        void operator()()
-        {
-            resume(std::move(cb)(sink.release()));
-        }
-    };
-
-    return suspend(
-        [&](resumer resume)
-        {
-            finish_ = on_finish(
-                this->parser.set_body<T>(
-                    std::forward<ValueSink>(sink)),
-                resume,
-                std::forward<Callback>(callback));
-        });
-}
-
-//-----------------------------------------------
-
-#ifdef BOOST_HTTP_HAS_CORO
-
-/** Create a route handler from a coroutine function
-
-    This is a convenience function for creating
-    route handlers from coroutine functions.
-
-    @par Signature
-    The coroutine function must have this signature:
-    @code
-    capy::task<route_result>( route_params& rp );
-    @endcode
-
-    @param f The coroutine function to invoke.
-    @return A route handler object.
-*/
-inline
-auto
-co_route(std::function<
-    capy::task<route_result>(route_params&)> f)
-{
-    return
-        [f_ = std::move(f)]( route_params& rp )
-        {
-            return rp.spawn(f_(rp));
-        };
-}
-
-#endif
-
 } // http
 } // boost
 

include/boost/http/server/router_types.hpp

@@ -42,33 +42,6 @@ using route_result = system::error_code;
 */
 enum class route
 {
-    /** The handler requests that the connection be closed.
-
-        No further requests will be processed. The caller should
-        close the connection once the current response, if any,
-        has been sent.
-    */
-    close = 1,
-
-    /** The handler completed the request.
-
-        The response has been fully transmitted, and no further
-        handlers or routes will be invoked. The caller should continue
-        by either reading the next request on a persistent connection
-        or closing the session if it is not keep-alive.
-    */
-    complete,
-
-    /** The handler is suspending the route.
-
-        When the handler returns this value, the router is placed into
-        a suspended state which can later be reactivated by invoking
-        @ref router::resume. Depending on the implementation,
-        this might detach the handler from the session until it is
-        resumed.
-    */
-    suspend,
-
     /** The handler declined to process the request.
 
         The handler chose not to generate a response. The caller
@@ -88,15 +61,7 @@ enum class route
         caller stops invoking handlers in this route and resumes
         evaluation with the next candidate route.
     */
-    next_route,
-
-    /** The request was handled.
-
-        The route handler processed the request and prepared
-        the response serializer. The caller will send the response
-        before reading the next request or closing the connection.
-    */
-    send
+    next_route
 };
 
 //------------------------------------------------
@@ -152,160 +117,6 @@ inline bool is_route_result(
 
 //------------------------------------------------
 
-class resumer;
-
-/** Function to suspend a route handler from its session
-
-    This holds an reference to an implementation
-    which suspends the router which dispatched the handler.
-*/
-class suspender
-{
-public:
-    /** Base class of the implementation
-    */
-    struct BOOST_HTTP_SYMBOL_VISIBLE
-        owner
-    {
-        BOOST_HTTP_DECL
-        virtual resumer do_suspend();
-        virtual void do_resume(route_result const&) = 0;
-        virtual void do_resume(std::exception_ptr) = 0;
-    };
-
-    suspender() = default;
-    suspender(suspender const&) = default;
-    suspender& operator=(suspender const&) = default;
-
-    explicit
-    suspender(
-        owner& who) noexcept
-        : p_(&who)
-    {
-    }
-
-    /** Suspend and invoke the given function
-
-        The function will be invoked with this equivalent signature:
-        @code
-        void( resumer );
-        @endcode
-
-        @return A @ref route_result equal to @ref route::suspend
-    */
-    template<class F>
-    route_result    
-    operator()(F&& f);
-
-private:
-    friend resumer;
-    // Clang doesn't consider uninstantiated templates
-    // when checking for unused private fields.
-    owner* p_
-    #if defined(__clang__)
-        __attribute__((unused))
-    #endif
-        = nullptr; 
-};
-
-//------------------------------------------------
-
-/** Function to resume a suspended route.
-
-    This holds a reference to an implementation which resumes the handler's
-    session. The resume function is typically obtained at the time the
-    route is suspended.
-*/
-class resumer
-{
-public:
-    /** Constructor
-
-        Default constructed resume functions will
-        be empty. An exception is thrown when
-        attempting to invoke an empty object.
-    */
-    resumer() = default;
-
-    /** Constructor
-
-        Copies of resume functions behave the same
-        as the original
-    */
-    resumer(resumer const&) = default;
-
-    /** Assignment
-
-        Copies of resume functions behave the same
-        as the original
-    */
-    resumer& operator=(resumer const&) = default;
-
-    /** Constructor
-    */
-    explicit
-    resumer(
-        suspender::owner& who) noexcept
-        : p_(&who)
-    {
-    }
-
-    /** Resume the session
-
-        When a session is resumed, routing continues as if the handler
-        had returned the @ref route_result contained in @p rv.
-
-        @param rv The route result to resume with.
-
-        @throw std::invalid_argument If the object is empty.
-    */
-    void operator()(
-        route_result const& rv) const
-    {
-        if(! p_)
-            detail::throw_invalid_argument();
-        p_->do_resume(rv);
-    }
-
-    /** Resume the session with an exception
-
-        When a session is resumed with an exception, the exception
-        is propagated through the router's error handling mechanism.
-
-        @param ep The exception to propagate.
-
-        @throw std::invalid_argument If the object is empty.
-    */
-    void operator()(
-        std::exception_ptr ep) const
-    {
-        if(! p_)
-            detail::throw_invalid_argument();
-        p_->do_resume(ep);
-    }
-
-private:
-    suspender::owner* p_
-    #if defined(__clang__)
-        __attribute__((unused))
-    #endif
-        = nullptr; 
-};
-
-template<class F>
-auto    
-suspender::
-operator()(F&& f) ->
-    route_result
-{
-    if(! p_)
-        detail::throw_logic_error();
-    std::forward<F>(f)(p_->do_suspend());
-    return route::suspend;
-}
-
-//------------------------------------------------
-
 namespace detail {
 class router_base;
 } // detail