Frame.hpp

Go to the documentation of this file.

// The Reactive C++ Toolbox.
// Copyright (C) 2013-2019 Swirly Cloud Limited
// Copyright (C) 2023 Reactive Markets Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef TOOLBOX_NET_FRAME_HPP
#define TOOLBOX_NET_FRAME_HPP
 
#include <toolbox/io/Buffer.hpp>
 
#include <cassert>
 
namespace toolbox {
inline namespace net {
namespace detail {
 
template <std::endian Native = std::endian::native>
constexpr std::uint16_t get_length(const char* buf, std::endian net_byte_order) noexcept
{
    // If byte swap required then 1, else 0.
    // These values provide indices into buffer, which is assumed to be at least 2 bytes long.
    const int bswap{Native != net_byte_order};
    return ((buf[!bswap] & 0xff) << 8) | (buf[bswap] & 0xff);
}
 
template <std::endian Native = std::endian::native>
inline void put_length(char* buf, std::uint16_t len, std::endian net_byte_order) noexcept
{
    // If byte swap required then 1, else 0.
    // These values provide indices into buffer, which is assumed to be at least 2 bytes long.
    const int bswap{Native != net_byte_order};
    buf[bswap] = 0xff & len;
    buf[!bswap] = 0xff & (len >> 8);
}
 
} // namespace detail
 
constexpr std::uint16_t get_length(const char* buf, std::endian net_byte_order) noexcept
{
    return detail::get_length<>(buf, net_byte_order);
}
 
inline std::uint16_t get_length(ConstBuffer buf, std::endian net_byte_order) noexcept
{
    assert(buffer_size(buf) >= 2);
    return get_length(buffer_cast<const char*>(buf), net_byte_order);
}
 
inline void put_length(char* buf, std::uint16_t len, std::endian net_byte_order) noexcept
{
    detail::put_length<>(buf, len, net_byte_order);
}
 
inline void put_length(MutableBuffer buf, std::uint16_t len, std::endian net_byte_order) noexcept
{
    assert(buffer_size(buf) >= 2);
    put_length(buffer_cast<char*>(buf), len, net_byte_order);
}
 
template <typename FnT>
std::size_t parse_frame(ConstBuffer buf, FnT fn, std::endian net_byte_order)
{
    std::size_t consumed{0};
    for (;;) {
        const auto* data = buffer_cast<const char*>(buf);
        const std::size_t size = buffer_size(buf);
        if (size < sizeof(std::uint16_t)) {
            break;
        }
        const auto total = get_length(data, net_byte_order);
        if (size < total) {
            break;
        }
        fn(ConstBuffer{data + sizeof(std::uint16_t), total - sizeof(std::uint16_t)});
        buf = advance(buf, total);
        consumed += total;
    }
    return consumed;
}
 
template <typename FnT>
std::size_t parse_frame(std::string_view buf, FnT fn, std::endian net_byte_order)
{
    return parse_frame(ConstBuffer{buf.data(), buf.size()}, fn, net_byte_order);
}
 
} // namespace net
} // namespace toolbox
 
#endif // TOOLBOX_NET_FRAME_HPP