OutputStreamer.hh

#ifndef avro_OutputStreamer_hh__
#define avro_OutputStreamer_hh__

#include <iostream>
#include <stdint.h>

namespace avro {

    
class OutputStreamer {

  public:

    virtual ~OutputStreamer()
    { }

    virtual size_t writeByte(uint8_t byte) = 0;
    virtual size_t writeWord(uint32_t word) = 0;
    virtual size_t writeLongWord(uint64_t word) = 0;
    virtual size_t writeBytes(const void *bytes, size_t size) = 0;
};


    
class ScreenStreamer : public OutputStreamer {

    size_t writeByte(uint8_t byte) {
        std::cout << "0x" << std::hex << static_cast<int32_t>(byte) << std::dec << " ";
        return 1;
    }

    size_t writeWord(uint32_t word) {
        ScreenStreamer::writeBytes(&word, sizeof(word));
        return sizeof(uint32_t);
    }

    size_t writeLongWord(uint64_t word) {
        ScreenStreamer::writeBytes(&word, sizeof(word));
        return sizeof(uint64_t);
    }

    size_t writeBytes(const void *bytes, size_t size) {
        const uint8_t *ptr = reinterpret_cast<const uint8_t *>(bytes);
        for (size_t i= 0; i < size; ++i) {
            ScreenStreamer::writeByte(*ptr++);
        }
        std::cout << std::endl;
        return size;
    }

};

    
class OStreamer : public OutputStreamer {

  public:

    OStreamer(std::ostream &os) :
        os_(os)
    {}

    size_t writeByte(uint8_t byte) {
        os_.put(byte);
        return 1;
    }

    size_t writeWord(uint32_t word) {
        os_.write(reinterpret_cast<char *>(&word), sizeof(word));
        return sizeof(uint32_t);
    }

    size_t writeLongWord(uint64_t word) {
        os_.write(reinterpret_cast<char *>(&word), sizeof(word));
        return sizeof(uint64_t);
    }

    size_t writeBytes(const void *bytes, size_t size) {
        os_.write(reinterpret_cast<const char *>(bytes), size);
        return size;
    }

  private:

    std::ostream &os_;
};

} // namespace avro

#endif