exporter.h

#ifndef DBALLE_EXPORTER_H
#define DBALLE_EXPORTER_H

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

namespace wreport {
struct Bulletin;
}

namespace dballe {

class ExporterOptions
{
public:
    std::string template_name;
    int centre      = MISSING_INT;
    int subcentre   = MISSING_INT;
    int application = MISSING_INT;

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

    void print(FILE* out);

    std::string to_string() const;

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

    static const ExporterOptions defaults;

    friend class Exporter;

protected:
    ExporterOptions()                                  = default;
    ExporterOptions(const ExporterOptions&)            = default;
    ExporterOptions(ExporterOptions&&)                 = default;
    ExporterOptions& operator=(const ExporterOptions&) = default;
    ExporterOptions& operator=(ExporterOptions&&)      = default;
};

class Exporter
{
protected:
    ExporterOptions opts;

    Exporter(const ExporterOptions& opts);

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

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

    virtual std::string
    to_binary(const std::vector<std::shared_ptr<Message>>& messages) const = 0;

    virtual std::unique_ptr<wreport::Bulletin>
    to_bulletin(const std::vector<std::shared_ptr<Message>>& msgs) const;

    virtual std::unique_ptr<wreport::Bulletin> make_bulletin() const;

    static std::unique_ptr<Exporter>
    create(Encoding type,
           const ExporterOptions& opts = ExporterOptions::defaults);
};

class BulletinExporter : public Exporter
{
public:
    using Exporter::Exporter;

    std::unique_ptr<wreport::Bulletin> to_bulletin(
        const std::vector<std::shared_ptr<Message>>& msgs) const override = 0;
};

} // namespace dballe

#endif