processor.h

#ifndef DBALLE_CMDLINE_PROCESSOR_H
#define DBALLE_CMDLINE_PROCESSOR_H
 
#include <dballe/exporter.h>
#include <dballe/importer.h>
#include <dballe/msg/msg.h>
#include <list>
#include <stdexcept>
#include <string>
 
#define DBALLE_JSON_VERSION "0.1"
 
namespace wreport {
struct Bulletin;
}
 
namespace dballe {
namespace cmdline {

struct ProcessingException : public std::exception
{
    std::string filename;
    unsigned index;
    std::string msg;

    ProcessingException(const std::string& filename, unsigned index,
                        const std::string& msg)
        : filename(filename), index(index)
    {
        initmsg(filename, index, msg.c_str());
    }

    ProcessingException(const std::string& filename, unsigned index,
                        const std::exception& original)
        : filename(filename), index(index)
    {
        initmsg(filename, index, original.what());
    }

    ProcessingException(const std::string& filename, unsigned index,
                        const std::string& msg, const std::exception& original)
        : filename(filename), index(index)
    {
        initmsg(filename, index, msg.c_str());
        this->msg += ": ";
        this->msg += original.what();
    }
 
    virtual ~ProcessingException() noexcept {}
 
    const char* what() const noexcept override { return msg.c_str(); }
 
protected:
    void initmsg(const std::string& fname, unsigned index, const char* msg);
};
 
struct Item
{
    unsigned idx;
    BinaryMessage* rmsg;
    wreport::Bulletin* bulletin;
    std::vector<std::shared_ptr<Message>>* msgs;
 
    Item();
    ~Item();

    void decode(Importer& imp, bool print_errors = false);

    void set_msgs(std::vector<std::shared_ptr<Message>>* new_msgs);

    void processing_failed(std::exception& e) const __attribute__((noreturn));
};
 
struct Action
{
    virtual ~Action() {}
    virtual bool operator()(const Item& item) = 0;
};
 
struct IndexMatcher
{
    std::vector<std::pair<int, int>> ranges;
 
    void parse(const std::string& str);
 
    bool match(int val) const;
};
 
struct ReaderOptions
{
    int category               = -1;
    int subcategory            = -1;
    int checkdigit             = -1;
    int unparsable             = 0;
    int parsable               = 0;
    const char* index_filter   = nullptr;
    const char* input_type     = "auto";
    const char* fail_file_name = nullptr;
};
 
struct Filter
{
    impl::ExporterOptions export_opts;
    int category    = -1;
    int subcategory = -1;
    int checkdigit  = -1;
    int unparsable  = 0;
    int parsable    = 0;
    IndexMatcher imatcher;
    Matcher* matcher = nullptr;
 
    Filter();
    Filter(const ReaderOptions& opts);
    ~Filter();
 
    void set_index_filter(const std::string& val);

    void matcher_reset();

    void matcher_from_record(const Query& query);
 
    bool match_index(int idx) const;
    bool match_common(
        const BinaryMessage& rmsg,
        const std::vector<std::shared_ptr<dballe::Message>>* msgs) const;
    bool
    match_msgs(const std::vector<std::shared_ptr<dballe::Message>>& msgs) const;
    bool match_bufrex(
        const BinaryMessage& rmsg, const wreport::Bulletin* rm,
        const std::vector<std::shared_ptr<dballe::Message>>* msgs) const;
    bool
    match_bufr(const BinaryMessage& rmsg, const wreport::Bulletin* rm,
               const std::vector<std::shared_ptr<dballe::Message>>* msgs) const;
    bool
    match_crex(const BinaryMessage& rmsg, const wreport::Bulletin* rm,
               const std::vector<std::shared_ptr<dballe::Message>>* msgs) const;
    bool
    match_json(const BinaryMessage& rmsg,
               const std::vector<std::shared_ptr<dballe::Message>>* msgs) const;
    bool match_item(const Item& item) const;
};
 
class Reader
{
protected:
    std::string input_type;
    const char* fail_file_name;
 
    void read_csv(const std::list<std::string>& fnames, Action& action);
    void read_json(const std::list<std::string>& fnames, Action& action);
    void read_file(const std::list<std::string>& fnames, Action& action);
 
public:
    impl::ImporterOptions import_opts;
    Filter filter;
    bool verbose             = false;
    unsigned count_successes = 0;
    unsigned count_failures  = 0;
 
    Reader(const ReaderOptions& opts);
 
    bool has_fail_file() const;
 
    void read(const std::list<std::string>& fnames, Action& action);
};
 
} // namespace cmdline
} // namespace dballe
#endif