parser.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <algorithm>
#include <array>
#include <bit>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <istream>
#include <optional>
#include <span>
#include <vector>
#include <version>
 
#ifdef __cpp_lib_expected
#include <expected>
#endif
 
#include "itch/messages.hpp"
 
namespace itch {
 
using MessageCallback = std::function<void(const Message&)>;
 
enum class ParseError {
    truncated,      
    unknown_type,   
    size_mismatch,  
};
 
using ErrorCallback = std::function<void(ParseError, char)>;
 
class Parser {
   public:
    Parser() = default;
 
    auto parse(const char* data, size_t size, const MessageCallback& callback) -> void;
 
    auto parse(const char* data, size_t size) -> std::vector<Message>;
 
    auto parse(const char* data, size_t size, const std::vector<char>& messages)
        -> std::vector<Message>;
 
    auto parse(std::istream& data, const MessageCallback& callback) -> void;
 
    auto parse(std::istream& data) -> std::vector<Message>;
 
    auto parse(std::istream& data, const std::vector<char>& messages) -> std::vector<Message>;
 
    auto parse(std::span<const std::byte> data, const MessageCallback& callback) -> void;
 
    auto parse(std::span<const std::byte> data) -> std::vector<Message>;
 
    auto parse(std::span<const std::byte> data, const std::vector<char>& messages)
        -> std::vector<Message>;
 
#ifdef __cpp_lib_expected
    [[nodiscard]] auto try_parse(std::span<const std::byte> data, const MessageCallback& callback)
        -> std::expected<void, ParseError>;
 
    [[nodiscard]] auto try_parse(std::span<const std::byte> data
    ) -> std::expected<std::vector<Message>, ParseError>;
#endif
 
    auto set_error_callback(ErrorCallback callback) -> void;
 
    [[nodiscard]] auto unknown_message_count() const noexcept -> std::uint64_t {
        return m_unknown_message_count;
    }
 
    [[nodiscard]] auto malformed_message_count() const noexcept -> std::uint64_t {
        return m_malformed_message_count;
    }
 
    auto reset_diagnostics() noexcept -> void {
        m_unknown_message_count   = 0;
        m_malformed_message_count = 0;
    }
 
   private:
    auto parse_impl(const char* data, std::size_t size, const MessageCallback& callback)
        -> std::optional<ParseError>;
 
    auto report_error(ParseError error, char message_type) -> void;
 
    ErrorCallback m_error_callback {};
    std::uint64_t m_unknown_message_count {0};
    std::uint64_t m_malformed_message_count {0};
};
 
namespace utils {
 
template <std::integral IntType>
[[nodiscard]] constexpr auto swap_bytes(IntType value) noexcept -> IntType {
#ifdef __cpp_lib_byteswap
    return std::byteswap(value);
#else
    if constexpr (sizeof(IntType) == 1) {
        return value;
    } else {
        auto bytes = std::bit_cast<std::array<std::byte, sizeof(IntType)>>(value);
        std::ranges::reverse(bytes);
        return std::bit_cast<IntType>(bytes);
    }
#endif
}
 
template <std::integral IntType>
[[nodiscard]] constexpr auto from_big_endian(IntType value) noexcept -> IntType {
    if constexpr (std::endian::native == std::endian::little) {
        return swap_bytes(value);
    } else {
        return value;
    }
}
 
template <typename ValueType>
auto unpack(const char* buffer, std::size_t& offset) -> ValueType;
 
inline auto unpack_string(const char* buffer, std::size_t& offset, char* dest, std::size_t size)
    -> void;
 
inline auto unpack_timestamp(const char* buffer, std::size_t& offset) -> std::uint64_t;
}  // namespace utils
 
}  // namespace itch