DataFile.hh

#ifndef avro_DataFile_hh__
#define avro_DataFile_hh__

#include "Encoder.hh"
#include "buffer/Buffer.hh"
#include "ValidSchema.hh"
#include "Specific.hh"
#include "Stream.hh"

#include <map>
#include <string>
#include <vector>

#include "boost/array.hpp"
#include "boost/utility.hpp"

namespace avro {

typedef boost::array<uint8_t, 16> DataFileSync;

class DataFileWriterBase : boost::noncopyable {
    const std::string filename_;
    const ValidSchema schema_;
    const EncoderPtr encoderPtr_;
    const size_t syncInterval_;

    std::auto_ptr<OutputStream> stream_;
    std::auto_ptr<OutputStream> buffer_;
    const DataFileSync sync_;
    int64_t objectCount_;

    typedef std::map<std::string, std::vector<uint8_t> > Metadata;

    Metadata metadata_;

    static std::auto_ptr<OutputStream> makeStream(const char* filename);
    static DataFileSync makeSync();

    void writeHeader();
    void setMetadata(const std::string& key, const std::string& value);

    void sync();

public:
    Encoder& encoder() const { return *encoderPtr_; }
    
    void syncIfNeeded();

    void incr() {
        ++objectCount_;
    }
    DataFileWriterBase(const char* filename, const ValidSchema& schema,
        size_t syncInterval);

    ~DataFileWriterBase();
    void close();

    const ValidSchema& schema() const { return schema_; }

    void flush();
};

template <typename T>
class DataFileWriter : boost::noncopyable {
    std::auto_ptr<DataFileWriterBase> base_;
public:
    DataFileWriter(const char* filename, const ValidSchema& schema,
        size_t syncInterval = 16 * 1024) :
        base_(new DataFileWriterBase(filename, schema, syncInterval)) { }

    void write(const T& datum) {
        base_->syncIfNeeded();
        avro::encode(base_->encoder(), datum);
        base_->incr();
    }

    void close() { base_->close(); }

    const ValidSchema& schema() const { return base_->schema(); }

    void flush() { base_->flush(); }
};

class DataFileReaderBase : boost::noncopyable {
    const std::string filename_;
    const std::auto_ptr<InputStream> stream_;
    const DecoderPtr decoder_;
    int64_t objectCount_;

    ValidSchema readerSchema_;
    ValidSchema dataSchema_;
    DecoderPtr dataDecoder_;
    std::auto_ptr<InputStream> dataStream_;
    typedef std::map<std::string, std::vector<uint8_t> > Metadata;

    Metadata metadata_;
    DataFileSync sync_;

    void readHeader();

    bool readDataBlock();
public:
    Decoder& decoder() { return *dataDecoder_; }

    bool hasMore();

    void decr() { --objectCount_; }

    DataFileReaderBase(const char* filename);

    void init();

    void init(const ValidSchema& readerSchema);

    const ValidSchema& readerSchema() { return readerSchema_; }

    const ValidSchema& dataSchema() { return dataSchema_; }

    void close();
};

template <typename T>
class DataFileReader : boost::noncopyable {
    std::auto_ptr<DataFileReaderBase> base_;
public:
    DataFileReader(const char* filename, const ValidSchema& readerSchema) :
        base_(new DataFileReaderBase(filename)) {
        base_->init(readerSchema);
    }

    DataFileReader(const char* filename) :
        base_(new DataFileReaderBase(filename)) {
        base_->init();
    }


    DataFileReader(std::auto_ptr<DataFileReaderBase> base) : base_(base) {
        base_->init();
    }

    DataFileReader(std::auto_ptr<DataFileReaderBase> base,
        const ValidSchema& readerSchema) : base_(base) {
        base_->init(readerSchema);
    }

    bool read(T& datum) {
        if (base_->hasMore()) {
            base_->decr();
            avro::decode(base_->decoder(), datum);
            return true;
        }
        return false;
    }

    const ValidSchema& readerSchema() { return base_->readerSchema(); }

    const ValidSchema& dataSchema() { return base_->dataSchema(); }

    void close() { return base_->close(); }
};

}   // namespace avro
#endif