websocket.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#ifndef PACKIO_EXTRA_WEBSOCKET_H
#define PACKIO_EXTRA_WEBSOCKET_H
 
 
#include "../internal/config.h"
#include "../internal/utils.h"
 
#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
 
namespace packio {
namespace extra {
 
template <typename Websocket, bool kBinary = false>
class websocket_adapter : public Websocket {
public:
    using protocol_type = typename Websocket::next_layer_type::protocol_type;
 
    template <typename... Args>
    websocket_adapter(Args&&... args) : Websocket(std::forward<Args>(args)...)
    {
        Websocket::binary(kBinary);
    }
 
    template <typename Buffer, typename Handler>
    auto async_write_some(Buffer&& buffer, Handler&& handler)
    {
        internal::set_no_delay(boost::beast::get_lowest_layer(*this).socket());
        return Websocket::async_write(
            std::forward<Buffer>(buffer), std::forward<Handler>(handler));
    }
 
    template <typename... Args>
    auto close(Args&&... args)
    {
        return boost::beast::get_lowest_layer(*this).socket().close(
            std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    auto cancel(Args&&...)
    {
        static_assert(
            internal::always_false_v<Args...>,
            "websockets do not support cancel operations");
    }
};
 
template <typename Acceptor, typename WebsocketAdapter>
class websocket_acceptor_adapter : public Acceptor {
public:
    using Acceptor::Acceptor;
 
    WebsocketAdapter accept();
 
    template <typename Handler>
    void async_accept(Handler&& handler)
    {
        Acceptor::async_accept([handler = std::forward<Handler>(handler)](
                                   auto ec, auto sock) mutable {
            if (ec) {
                handler(ec, WebsocketAdapter(std::move(sock)));
                return;
            }
            auto ws = std::make_unique<WebsocketAdapter>(std::move(sock));
            ws->set_option(boost::beast::websocket::stream_base::timeout::suggested(
                boost::beast::role_type::server));
            ws->async_accept([handler = std::forward<Handler>(handler),
                              ws = std::move(ws)](auto ec) mutable {
                handler(ec, std::move(*ws));
            });
        });
    }
};
 
} // extra
} // packio
 
#endif // PACKIO_EXTRA_WEBSOCKET_H