boost_beast/include/boost/beast/websocket/detail/pausation.hpp

//
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//

#ifndef BOOST_BEAST_WEBSOCKET_DETAIL_PAUSATION_HPP
#define BOOST_BEAST_WEBSOCKET_DETAIL_PAUSATION_HPP

#include <boost/beast/core/handler_ptr.hpp>
#include <boost/asio/associated_allocator.hpp>
#include <boost/asio/coroutine.hpp>
#include <boost/assert.hpp>
#include <array>
#include <memory>
#include <new>
#include <utility>

namespace boost {
namespace beast {
namespace websocket {
namespace detail {

// A container that holds a suspended, asynchronous composed
// operation. The contained object may be invoked later to
// resume the operation, or the container may be destroyed.
//
class pausation
{
    struct base
    {
        base() = default;
        base(base &&) = delete;
        base(base const&) = delete;
        virtual ~base() = default;
        virtual void operator()() = 0;
    };

    template<class F>
    struct holder : base
    {
        F f;

        holder(holder&&) = default;

        template<class U>
        explicit
        holder(U&& u)
            : f(std::forward<U>(u))
        {
        }

        void
        operator()() override
        {
            F f_(std::move(f));
            this->~holder();
            // invocation of f_() can
            // assign a new object to *this.
            f_();
        }
    };

    struct exemplar : boost::asio::coroutine
    {
        struct H
        {
            void operator()();
        };

        struct T
        {
            using handler_type = H;
        };

        handler_ptr<T, H> hp;

        void operator()();
    };

    template<class Op>
    class saved_op
    {
        Op* op_ = nullptr;

    public:
        ~saved_op()
        {
            if(op_)
            {
                Op op(std::move(*op_));
                op_->~Op();
                typename std::allocator_traits<
                    boost::asio::associated_allocator_t<Op>>::
                        template rebind_alloc<Op> alloc{
                            boost::asio::get_associated_allocator(op)};
                std::allocator_traits<
                    decltype(alloc)>::deallocate(alloc, op_, 1);
            }
        }

        saved_op(saved_op&& other)
            : op_(other.op_)
        {
            other.op_ = nullptr;
        }

        saved_op& operator=(saved_op&& other)
        {
            BOOST_ASSERT(! op_);
            op_ = other.op_;
            other.op_ = 0;
            return *this;
        }

        explicit
        saved_op(Op&& op)
        {
            typename std::allocator_traits<
                boost::asio::associated_allocator_t<Op>>::
                    template rebind_alloc<Op> alloc{
                        boost::asio::get_associated_allocator(op)};
            auto const p = std::allocator_traits<
                decltype(alloc)>::allocate(alloc, 1);
            op_ = new(p) Op{std::move(op)};
        }

        void
        operator()()
        {
            BOOST_ASSERT(op_);
            Op op{std::move(*op_)};
            typename std::allocator_traits<
                boost::asio::associated_allocator_t<Op>>::
                    template rebind_alloc<Op> alloc{
                        boost::asio::get_associated_allocator(op)};
            std::allocator_traits<
                decltype(alloc)>::deallocate(alloc, op_, 1);
            op_ = nullptr;
            op();
        }
    };

    using buf_type = char[sizeof(holder<exemplar>)];

    base* base_ = nullptr;
    alignas(holder<exemplar>) buf_type buf_;

public:
    pausation() = default;
    pausation(pausation const&) = delete;
    pausation& operator=(pausation const&) = delete;

    ~pausation()
    {
        if(base_)
            base_->~base();
    }

    pausation(pausation&& other)
    {
        boost::ignore_unused(other);
        BOOST_ASSERT(! other.base_);
    }

    pausation&
    operator=(pausation&& other)
    {
        boost::ignore_unused(other);
        BOOST_ASSERT(! base_);
        BOOST_ASSERT(! other.base_);
        return *this;
    }

    template<class F>
    void
    emplace(F&& f);

    template<class F>
    void
    save(F&& f);

    explicit
    operator bool() const
    {
        return base_ != nullptr;
    }

    bool
    maybe_invoke()
    {
        if(base_)
        {
            auto const basep = base_;
            base_ = nullptr;
            (*basep)();
            return true;
        }
        return false;
    }
};

template<class F>
void
pausation::emplace(F&& f)
{
    using type = holder<typename std::decay<F>::type>;
    static_assert(sizeof(buf_type) >= sizeof(type),
        "buffer too small");
    BOOST_ASSERT(! base_);
    base_ = ::new(buf_) type{std::forward<F>(f)};
}

template<class F>
void
pausation::save(F&& f)
{
    emplace(saved_op<F>{std::move(f)});
}

} // detail
} // websocket
} // beast
} // boost

#endif