file.h

#ifndef DBALLE_FILE_H
#define DBALLE_FILE_H

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

namespace dballe {

class File
{
public:
    virtual ~File();

    virtual std::string pathname() const = 0;

    virtual Encoding encoding() const = 0;

    virtual void close() = 0;

    virtual BinaryMessage read() = 0;

    virtual bool foreach (std::function<bool(const BinaryMessage&)> dest) = 0;

    virtual void write(const std::string& msg) = 0;

    static std::unique_ptr<File> create(const std::string& pathname,
                                        const char* mode);

    static std::unique_ptr<File>
    create(Encoding type, const std::string& pathname, const char* mode);

    static std::unique_ptr<File> create(FILE* file, bool close_on_exit,
                                        const std::string& name = "(fp)");

    static std::unique_ptr<File> create(Encoding type, FILE* file,
                                        bool close_on_exit,
                                        const std::string& name = "(fp)");

    static const char* encoding_name(Encoding enc);

    static Encoding parse_encoding(const char* s);

    static Encoding parse_encoding(const std::string& s);
};

class BinaryMessage
{
public:
    Encoding encoding;

    std::string data;

    std::string pathname;

    off_t offset = (off_t)-1;

    int index = MISSING_INT;

    BinaryMessage(Encoding encoding) : encoding(encoding) {}
    BinaryMessage(const BinaryMessage&)            = default;
    BinaryMessage(BinaryMessage&&)                 = default;
    BinaryMessage& operator=(const BinaryMessage&) = default;
    BinaryMessage& operator=(BinaryMessage&&)      = default;

    operator bool() const;
};

std::ostream& operator<<(std::ostream&, const dballe::Encoding&);

} // namespace dballe

#endif