robot/include/boost/beast/_experimental/test/detail/stream_state.ipp

//
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
// Copyright (c) 2020 Richard Hodges (hodges.r@gmail.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_TEST_DETAIL_STREAM_STATE_IPP
#define BOOST_BEAST_TEST_DETAIL_STREAM_STATE_IPP

#include <boost/beast/_experimental/test/error.hpp>
#include <boost/make_shared.hpp>

namespace boost {
namespace beast {
namespace test {

namespace detail {

//------------------------------------------------------------------------------

stream_service::
stream_service(net::execution_context& ctx)
    : beast::detail::service_base<stream_service>(ctx)
    , sp_(boost::make_shared<stream_service_impl>())
{
}

void
stream_service::
shutdown()
{
    std::vector<std::unique_ptr<detail::stream_read_op_base>> v;
    std::lock_guard<std::mutex> g1(sp_->m_);
    v.reserve(sp_->v_.size());
    for(auto p : sp_->v_)
    {
        std::lock_guard<std::mutex> g2(p->m);
        v.emplace_back(std::move(p->op));
        p->code = detail::stream_status::eof;
    }
}

auto
stream_service::
make_impl(
    net::any_io_executor exec,
    test::fail_count* fc) ->
    boost::shared_ptr<detail::stream_state>
{
#if defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
    auto& ctx = exec.context();
#else
    auto& ctx = net::query(
        exec,
        net::execution::context);
#endif
    auto& svc = net::use_service<stream_service>(ctx);
    auto sp = boost::make_shared<detail::stream_state>(exec, svc.sp_, fc);
    std::lock_guard<std::mutex> g(svc.sp_->m_);
    svc.sp_->v_.push_back(sp.get());
    return sp;
}

//------------------------------------------------------------------------------

void
stream_service_impl::
remove(stream_state& impl)
{
    std::lock_guard<std::mutex> g(m_);
    *std::find(
        v_.begin(), v_.end(),
            &impl) = std::move(v_.back());
    v_.pop_back();
}

//------------------------------------------------------------------------------

stream_state::
stream_state(
    net::any_io_executor exec_,
    boost::weak_ptr<stream_service_impl> wp_,
    fail_count* fc_)
    : exec(std::move(exec_))
    , wp(std::move(wp_))
    , fc(fc_)
{
}

stream_state::
~stream_state()
{
    // cancel outstanding read
    if(op != nullptr)
        (*op)(net::error::operation_aborted);
}

void
stream_state::
remove() noexcept
{
    auto sp = wp.lock();

    // If this goes off, it means the lifetime of a test::stream object
    // extended beyond the lifetime of the associated execution context.
    BOOST_ASSERT(sp);

    sp->remove(*this);
}

void
stream_state::
notify_read()
{
    if(op)
    {
        auto op_ = std::move(op);
        op_->operator()(error_code{});
    }
    else
    {
        cv.notify_all();
    }
}

void
stream_state::
cancel_read()
{
    std::unique_ptr<stream_read_op_base> p;
    {
        std::lock_guard<std::mutex> lock(m);
        code = stream_status::eof;
        p = std::move(op);
    }
    if(p != nullptr)
        (*p)(net::error::operation_aborted);
}

} // detail

} // test
} // beast
} // boost

#endif // BOOST_BEAST_TEST_DETAIL_STREAM_STATE_IPP