input.h

#ifndef WREPORT_BUFR_INPUT_H
#define WREPORT_BUFR_INPUT_H
 
#include <wreport/error.h>
#include <wreport/var.h>
#include <wreport/bulletin.h>
#include <string>
#include <functional>
 
namespace wreport {
struct Bulletin;
 
namespace bulletin {
struct AssociatedField;
}
 
namespace bufr {
 
struct DispatchToSubsets
{
    Bulletin& out;
    unsigned subset_count;
    DispatchToSubsets(Bulletin& out, unsigned subset_count) : out(out), subset_count(subset_count) {}
 
    void add_missing(Varinfo info)
    {
        for (unsigned i = 0; i < subset_count; ++i)
            out.subsets[i].store_variable_undef(info);
    }
    void add_same(const Var& var)
    {
        for (unsigned i = 0; i < subset_count; ++i)
            out.subsets[i].store_variable(Var(var));
    }
    void add_var(unsigned subset, Var&& var)
    {
        out.subsets[subset].store_variable(var);
    }
};
 
 
class Input
{
protected:
    void scan_section_length(unsigned sec_no);
 
public:
    const uint8_t* data;
 
    size_t data_len;
 
    const char* fname = nullptr;
 
    size_t start_offset = 0;
 
    unsigned s4_cursor = 0;
 
    uint8_t pbyte = 0;
 
    int pbyte_len = 0;
 
    unsigned sec[6];
 
 
    Input(const std::string& in);
 
    void scan_lead_sections();
 
    void scan_other_sections(bool has_optional);
 
    unsigned offset() const { return s4_cursor; }
 
    unsigned bits_left() const { return (data_len - s4_cursor) * 8 + pbyte_len; }
 
    inline unsigned read_byte(unsigned pos) const
    {
        return (unsigned)data[pos];
    }
 
    inline unsigned read_byte(unsigned section, unsigned pos) const
    {
        return (unsigned)data[sec[section] + pos];
    }
 
    unsigned read_number(unsigned pos, unsigned byte_len) const
    {
        unsigned res = 0;
        for (unsigned i = 0; i < byte_len; ++i)
        {
            res <<= 8;
            res |= data[pos + i];
        }
        return res;
    }
 
    inline unsigned read_number(unsigned section, unsigned pos, unsigned byte_len) const
    {
        return read_number(sec[section] + pos, byte_len);
    }
 
    uint32_t get_bits(unsigned n)
    {
        uint32_t result = 0;
 
        if (s4_cursor == data_len)
            parse_error("end of buffer while looking for %d bits of bit-packed data", n);
 
        // TODO: review and benchmark and possibly simplify
        // (a possible alternative approach is to keep a current bitmask that
        // starts at 0x80 and is shifted right by 1 at each read until it
        // reaches 0, and get rid of pbyte_len)
        for (unsigned i = 0; i < n; i++)
        {
            if (pbyte_len == 0)
            {
                pbyte_len = 8;
                pbyte = data[s4_cursor++];
            }
            result <<= 1;
            if (pbyte & 0x80)
                result |= 1;
            pbyte <<= 1;
            pbyte_len--;
        }
 
        return result;
    }
 
    void debug_dump_next_bits(const char* desc, int count) const;
 
    void parse_error(const char* fmt, ...) const WREPORT_THROWF_ATTRS(2, 3);
 
    void parse_error(unsigned pos, const char* fmt, ...) const WREPORT_THROWF_ATTRS(3, 4);
 
    void parse_error(unsigned section, unsigned pos, const char* fmt, ...) const WREPORT_THROWF_ATTRS(4, 5);
 
    void check_available_data(unsigned pos, size_t datalen, const char* expected);
 
    void check_available_message_data(unsigned section, unsigned pos, size_t datalen, const char* expected);
 
    void check_available_section_data(unsigned section, unsigned pos, size_t datalen, const char* expected);
 
    void decode_compressed_number(Var& dest, uint32_t base, unsigned diffbits);
 
    void decode_number(Var& dest);
 
    bool decode_compressed_base(Varinfo info, uint32_t& base, uint32_t& diffbits);
 
    void decode_compressed_number(Varinfo info, unsigned subsets, std::function<void(unsigned, Var&&)> dest);
 
    void decode_string(Varinfo info, unsigned subsets, DispatchToSubsets& dest);
 
    void decode_compressed_number(Varinfo info, unsigned subsets, DispatchToSubsets& dest);
 
    void decode_compressed_number(Varinfo info, const bulletin::AssociatedField& afield, unsigned subsets, std::function<void(unsigned, Var&&)> dest);
 
    void decode_compressed_semantic_number(Var& dest, unsigned subsets);
 
    bool decode_string(unsigned bit_len, char* str, size_t& len);
 
    void decode_string(Var& dest);
 
    void decode_string(Var& dest, unsigned subsets);
 
    void decode_string(Varinfo info, unsigned subsets, std::function<void(unsigned, Var&&)> dest);
 
    void decode_binary(Var& dest);
 
    std::string decode_uncompressed_bitmap(unsigned size);
 
    std::string decode_compressed_bitmap(unsigned size);
};
 
}
}
#endif