importer.h

#ifndef DBALLE_IMPORTER_H
#define DBALLE_IMPORTER_H

#include <cstdio>
#include <dballe/fwd.h>
#include <functional>
#include <memory>
#include <string>
#include <vector>

namespace wreport {
struct Bulletin;
}

namespace dballe {

class ImporterOptions
{
public:
    bool simplified = true;

    enum class DomainErrors {
        THROW = 0,
        UNSET = 1,
        CLAMP = 2,
        TAG   = 3,
    } domain_errors = DomainErrors::THROW;

    bool operator==(const ImporterOptions&) const;
    bool operator!=(const ImporterOptions&) const;

    void print(FILE* out);

    std::string to_string() const;

    static std::unique_ptr<ImporterOptions> create();

    static std::unique_ptr<ImporterOptions> create(const std::string& s);

    static const ImporterOptions defaults;

    friend class Importer;

protected:
    ImporterOptions() = default;
    ImporterOptions(const std::string& s);
    ImporterOptions(const ImporterOptions&)            = default;
    ImporterOptions(ImporterOptions&&)                 = default;
    ImporterOptions& operator=(const ImporterOptions&) = default;
    ImporterOptions& operator=(ImporterOptions&&)      = default;
};

class Importer
{
protected:
    ImporterOptions opts;

    Importer(const ImporterOptions& opts);

public:
    Importer(const Importer&) = delete;
    Importer(Importer&&)      = delete;
    virtual ~Importer();

    Importer& operator=(const Importer&) = delete;
    Importer& operator=(Importer&&)      = delete;

    virtual Encoding encoding() const = 0;

    std::vector<std::shared_ptr<Message>>
    from_binary(const BinaryMessage& msg) const;

    virtual std::vector<std::shared_ptr<Message>>
    from_bulletin(const wreport::Bulletin& msg) const;

    virtual bool foreach_decoded(
        const BinaryMessage& msg,
        std::function<bool(std::shared_ptr<Message>)> dest) const = 0;

    static std::unique_ptr<Importer>
    create(Encoding type,
           const ImporterOptions& opts = ImporterOptions::defaults);

    static std::unique_ptr<Importer> create(Encoding type,
                                            const std::string& opts);
};

class BulletinImporter : public Importer
{
public:
    using Importer::Importer;

    std::vector<std::shared_ptr<Message>>
    from_bulletin(const wreport::Bulletin& msg) const override = 0;
};

} // namespace dballe

#endif