v5_pingresp.hpp

// Copyright Takatoshi Kondo 2022
//
// 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)
 
#if !defined(ASYNC_MQTT_PACKET_V5_PINGRESP_HPP)
#define ASYNC_MQTT_PACKET_V5_PINGRESP_HPP
 
#include <utility>
#include <numeric>
 
#include <boost/numeric/conversion/cast.hpp>
 
#include <async_mqtt/exception.hpp>
#include <async_mqtt/buffer.hpp>
 
#include <async_mqtt/util/move.hpp>
#include <async_mqtt/util/static_vector.hpp>
#include <async_mqtt/util/endian_convert.hpp>
 
#include <async_mqtt/packet/packet_id_type.hpp>
#include <async_mqtt/packet/fixed_header.hpp>
 
namespace async_mqtt::v5 {
 
namespace as = boost::asio;
 
class pingresp_packet {
public:
 
    pingresp_packet()
        : all_(all_.capacity())
    {
        all_[0] = static_cast<char>(make_fixed_header(control_packet_type::pingresp, 0b0000));
        all_[1] = char(0);
    }
 
    pingresp_packet(buffer buf) {
        // fixed_header
        if (buf.empty()) {
            throw make_error(
                errc::bad_message,
                "v5::pingresp_packet fixed_header doesn't exist"
            );
        }
        all_.push_back(buf.front());
        buf.remove_prefix(1);
        auto cpt_opt = get_control_packet_type_with_check(static_cast<std::uint8_t>(all_.back()));
        if (!cpt_opt || *cpt_opt != control_packet_type::pingresp) {
            throw make_error(
                errc::bad_message,
                "v5::pingresp_packet fixed_header is invalid"
            );
        }
 
        // remaining_length
        if (buf.empty()) {
            throw make_error(
                errc::bad_message,
                "v5::pingresp_packet remaining_length doesn't exist"
            );
        }
        all_.push_back(buf.front());
 
        if (static_cast<std::uint8_t>(all_.back()) != 0) {
            throw make_error(
                errc::bad_message,
                "v5::pingresp_packet remaining_length is invalid"
            );
        }
    }
 
    constexpr control_packet_type type() const {
        return control_packet_type::pingresp;
    }
 
    std::vector<as::const_buffer> const_buffer_sequence() const {
        std::vector<as::const_buffer> ret;
 
        ret.emplace_back(as::buffer(all_.data(), all_.size()));
        return ret;
    }
 
    std::size_t size() const {
        return all_.size();
    }
 
    static constexpr std::size_t num_of_const_buffer_sequence() {
        return 1; // all
    }
 
private:
    static_vector<char, 2> all_;
};
 
inline std::ostream& operator<<(std::ostream& o, pingresp_packet const& /*v*/) {
    o <<
        "v5::pingresp{}";
    return o;
}
 
} // namespace async_mqtt::v5
 
#endif // ASYNC_MQTT_PACKET_V5_PINGRESP_HPP