bulletin.h

#ifndef WREPORT_BULLETIN_H
#define WREPORT_BULLETIN_H
 
#include <wreport/var.h>
#include <wreport/subset.h>
#include <wreport/opcodes.h>
#include <wreport/tables.h>
#include <wreport/fwd.h>
#include <vector>
#include <memory>
 
namespace wreport {
 
class Bulletin
{
public:
    std::string fname;
 
    off_t offset = 0;
 
    uint8_t master_table_number = 0;
 
    uint8_t data_category = 0xff;
 
    uint8_t data_subcategory = 0xff;
 
    uint8_t data_subcategory_local = 0xff;
 
    uint16_t originating_centre = 0xffff;
 
    uint16_t originating_subcentre = 0xffff;
 
    uint8_t update_sequence_number = 0;
 
    uint16_t rep_year = 0;
    uint8_t rep_month = 0;
    uint8_t rep_day = 0;
    uint8_t rep_hour = 0;
    uint8_t rep_minute = 0;
    uint8_t rep_second = 0;
 
    Tables tables;
 
    std::vector<Varcode> datadesc;
 
    std::vector<Subset> subsets;
 
 
    Bulletin();
    virtual ~Bulletin();
 
    virtual void clear();
 
    virtual const char* encoding_name() const throw () = 0;
 
    Subset& obtain_subset(unsigned subsection);
 
    const Subset& subset(unsigned subsection) const;
 
    virtual void load_tables() = 0;
 
    virtual std::string encode() const = 0;
 
    void print(FILE* out) const;
 
    void print_structured(FILE* out) const;
 
    virtual void print_details(FILE* out) const;
 
    void print_datadesc(FILE* out, unsigned indent=0) const;
 
    virtual unsigned diff(const Bulletin& msg) const;
 
    virtual unsigned diff_details(const Bulletin& msg) const;
};
 
 
class BufrCodecOptions
{
public:
    bool decode_adds_undef_attrs = false;
 
    static std::unique_ptr<BufrCodecOptions> create();
 
protected:
    BufrCodecOptions();
};
 
 
class BufrBulletin : public Bulletin
{
public:
    uint8_t edition_number = 4;
 
    uint8_t master_table_version_number = 19;
 
    uint8_t master_table_version_number_local = 0;
 
    bool compression;
 
    std::string optional_section;
 
    unsigned section_end[6] = { 0, 0, 0, 0, 0, 0 };
 
 
    virtual ~BufrBulletin();
 
    void clear();
    const char* encoding_name() const throw () override { return "BUFR"; }
    void load_tables() override;
    std::string encode() const override;
    void print_details(FILE* out) const override;
    unsigned diff_details(const Bulletin& msg) const override;
 
    static bool read(FILE* in, std::string& buf, const char* fname=0, off_t* offset=0);
 
    static void write(const std::string& buf, FILE* out, const char* fname=0);
 
    static std::unique_ptr<BufrBulletin> create();
 
    static std::unique_ptr<BufrBulletin> decode_header(const std::string& raw, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<BufrBulletin> decode_header(const std::string& raw, const BufrCodecOptions& opts, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<BufrBulletin> decode(const std::string& raw, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<BufrBulletin> decode_verbose(const std::string& raw, FILE* out, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<BufrBulletin> decode(const std::string& raw, const BufrCodecOptions& opts, const char* fname="(memory)", size_t offset=0);
 
protected:
    BufrBulletin();
};
 
 
class CrexBulletin : public Bulletin
{
public:
    uint8_t edition_number = 2;
 
    uint8_t master_table_version_number = 19;
 
    uint8_t master_table_version_number_bufr = 19;
 
    uint8_t master_table_version_number_local = 0;
 
    bool has_check_digit = false;
 
 
    void clear();
    const char* encoding_name() const throw () override { return "CREX"; }
    void load_tables() override;
    std::string encode() const override;
    void print_details(FILE* out) const override;
    unsigned diff_details(const Bulletin& msg) const override;
 
    static bool read(FILE* in, std::string& buf, const char* fname=0, off_t* offset=0);
 
    static void write(const std::string& buf, FILE* out, const char* fname=0);
 
    static std::unique_ptr<CrexBulletin> create();
 
    static std::unique_ptr<CrexBulletin> decode_header(const std::string& raw, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<CrexBulletin> decode(const std::string& raw, const char* fname="(memory)", size_t offset=0);
 
    static std::unique_ptr<CrexBulletin> decode_verbose(const std::string& raw, FILE* out, const char* fname="(memory)", size_t offset=0);
 
protected:
    CrexBulletin();
};
 
 
namespace bulletin {
}
 
}
#endif