binarywriter.h

Go to the documentation of this file.

#ifndef IOUTILITIES_BINARYWRITER_H
#define IOUTILITIES_BINARYWRITER_H
 
#include "../conversion/binaryconversion.h"
 
#include <cstdint>
#include <cstring>
#include <ostream>
#include <string>
#include <vector>
 
namespace CppUtilities {
 
class CPP_UTILITIES_EXPORT BinaryWriter {
public:
    BinaryWriter(std::ostream *stream, bool giveOwnership = false);
    BinaryWriter(const BinaryWriter &other);
    BinaryWriter &operator=(const BinaryWriter &rhs) = delete;
    ~BinaryWriter();
 
    const std::ostream *stream() const;
    std::ostream *stream();
    void setStream(std::ostream *stream, bool giveOwnership = false);
    bool hasOwnership() const;
    void giveOwnership();
    void detatchOwnership();
    void flush();
    bool fail() const;
    void write(const char *buffer, std::streamsize length);
    void write(const std::vector<char> &buffer, std::streamsize length);
    void writeChar(char value);
    void writeByte(std::uint8_t value);
    void writeInt16BE(std::int16_t value);
    void writeUInt16BE(std::uint16_t value);
    void writeInt24BE(std::int32_t value);
    void writeUInt24BE(std::uint32_t value);
    void writeInt32BE(std::int32_t value);
    void writeUInt32BE(std::uint32_t value);
    void writeInt40BE(std::int64_t value);
    void writeUInt40BE(std::uint64_t value);
    void writeInt56BE(std::int64_t value);
    void writeUInt56BE(std::uint64_t value);
    void writeInt64BE(std::int64_t value);
    void writeUInt64BE(std::uint64_t value);
    void writeVariableLengthUIntBE(std::uint64_t value);
    void writeFloat32BE(float value);
    void writeFloat64BE(double value);
    void writeInt16LE(std::int16_t value);
    void writeUInt16LE(std::uint16_t value);
    void writeInt24LE(std::int32_t value);
    void writeUInt24LE(std::uint32_t value);
    void writeInt32LE(std::int32_t value);
    void writeUInt32LE(std::uint32_t value);
    void writeInt40LE(std::int64_t value);
    void writeUInt40LE(std::uint64_t value);
    void writeInt56LE(std::int64_t value);
    void writeUInt56LE(std::uint64_t value);
    void writeInt64LE(std::int64_t value);
    void writeUInt64LE(std::uint64_t value);
    void writeVariableLengthUIntLE(std::uint64_t value);
    void writeFloat32LE(float value);
    void writeFloat64LE(double value);
    void writeString(const std::string &value);
    void writeTerminatedString(const std::string &value);
    void writeLengthPrefixedString(const std::string &value);
    void writeLengthPrefixedCString(const char *value, std::size_t size);
    void writeBool(bool value);
    void writeSynchsafeUInt32BE(std::uint32_t valueToConvertAndWrite);
    void writeFixed8BE(float valueToConvertAndWrite);
    void writeFixed16BE(float valueToConvertAndWrite);
    void writeSynchsafeUInt32LE(std::uint32_t valueToConvertAndWrite);
    void writeFixed8LE(float valueToConvertAndWrite);
    void writeFixed16LE(float valueToConvertAndWrite);
 
    // declare further overloads for write() to ease use of BinaryWriter in templates
    void write(char oneChar);
    void write(std::uint8_t oneByte);
    void write(bool oneBool);
    void write(const std::string &lengthPrefixedString);
    void write(std::string_view lengthPrefixedString);
    void write(const char *lengthPrefixedString);
    void write(std::int16_t one16BitInt);
    void write(std::uint16_t one16BitUint);
    void write(std::int32_t one32BitInt);
    void write(std::uint32_t one32BitUint);
    void write(std::int64_t one64BitInt);
    void write(std::uint64_t one64BitUint);
    void write(float one32BitFloat);
    void write(double one64BitFloat);
 
private:
    void writeVariableLengthInteger(std::uint64_t size, void (*getBytes)(std::uint64_t, char *));
 
    std::ostream *m_stream;
    bool m_ownership;
    char m_buffer[8];
};
 
inline BinaryWriter::BinaryWriter(std::ostream *stream, bool giveOwnership)
    : m_stream(stream)
    , m_ownership(giveOwnership)
{
}
 
inline BinaryWriter::BinaryWriter(const BinaryWriter &other)
    : m_stream(other.m_stream)
    , m_ownership(false)
{
}
 
inline BinaryWriter::~BinaryWriter()
{
    if (m_ownership) {
        delete m_stream;
    }
}
 
inline std::ostream *BinaryWriter::stream()
{
    return m_stream;
}
 
inline const std::ostream *BinaryWriter::stream() const
{
    return m_stream;
}
 
inline bool BinaryWriter::hasOwnership() const
{
    return m_ownership;
}
 
inline void BinaryWriter::giveOwnership()
{
    if (m_stream) {
        m_ownership = true;
    }
}
 
inline void BinaryWriter::detatchOwnership()
{
    m_ownership = false;
}
 
inline void BinaryWriter::flush()
{
    m_stream->flush();
}
 
inline bool BinaryWriter::fail() const
{
    return m_stream ? m_stream->fail() : false;
}
 
inline void BinaryWriter::write(const char *buffer, std::streamsize length)
{
    m_stream->write(buffer, length);
}
 
inline void BinaryWriter::write(const std::vector<char> &buffer, std::streamsize length)
{
    m_stream->write(buffer.data(), length);
}
 
inline void BinaryWriter::writeChar(char value)
{
    m_buffer[0] = value;
    m_stream->write(m_buffer, 1);
}
 
inline void BinaryWriter::writeByte(std::uint8_t value)
{
    m_buffer[0] = *reinterpret_cast<char *>(&value);
    m_stream->write(m_buffer, 1);
}
 
inline void BinaryWriter::writeBool(bool value)
{
    writeByte(value ? 1 : 0);
}
 
inline void BinaryWriter::writeInt16BE(std::int16_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int16_t));
}
 
inline void BinaryWriter::writeUInt16BE(std::uint16_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint16_t));
}
 
inline void BinaryWriter::writeInt24BE(std::int32_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 1, 3);
}
 
inline void BinaryWriter::writeUInt24BE(std::uint32_t value)
{
    // discard most significant byte
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 1, 3);
}
 
inline void BinaryWriter::writeInt32BE(std::int32_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int32_t));
}
 
inline void BinaryWriter::writeUInt32BE(std::uint32_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint32_t));
}
 
inline void BinaryWriter::writeInt40BE(std::int64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 3, 5);
}
 
inline void BinaryWriter::writeUInt40BE(std::uint64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 3, 5);
}
 
inline void BinaryWriter::writeInt56BE(std::int64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 1, 7);
}
 
inline void BinaryWriter::writeUInt56BE(std::uint64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer + 1, 7);
}
 
inline void BinaryWriter::writeInt64BE(std::int64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int64_t));
}
 
inline void BinaryWriter::writeUInt64BE(std::uint64_t value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint64_t));
}
 
inline void BinaryWriter::writeVariableLengthUIntBE(std::uint64_t value)
{
    writeVariableLengthInteger(value, static_cast<void (*)(std::uint64_t, char *)>(&BE::getBytes));
}
 
inline void BinaryWriter::writeFloat32BE(float value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(float));
}
 
inline void BinaryWriter::writeFloat64BE(double value)
{
    BE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(double));
}
 
inline void BinaryWriter::writeInt16LE(std::int16_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int16_t));
}
 
inline void BinaryWriter::writeUInt16LE(std::uint16_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint16_t));
}
 
inline void BinaryWriter::writeInt24LE(std::int32_t value)
{
    // discard most significant byte
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 3);
}
 
inline void BinaryWriter::writeUInt24LE(std::uint32_t value)
{
    // discard most significant byte
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 3);
}
 
inline void BinaryWriter::writeInt32LE(std::int32_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int32_t));
}
 
inline void BinaryWriter::writeUInt32LE(std::uint32_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint32_t));
}
 
inline void BinaryWriter::writeInt40LE(std::int64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 5);
}
 
inline void BinaryWriter::writeUInt40LE(std::uint64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 5);
}
 
inline void BinaryWriter::writeInt56LE(std::int64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 7);
}
 
inline void BinaryWriter::writeUInt56LE(std::uint64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, 7);
}
 
inline void BinaryWriter::writeInt64LE(std::int64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::int64_t));
}
 
inline void BinaryWriter::writeUInt64LE(std::uint64_t value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(std::uint64_t));
}
 
inline void BinaryWriter::writeVariableLengthUIntLE(std::uint64_t value)
{
    writeVariableLengthInteger(value, static_cast<void (*)(std::uint64_t, char *)>(&LE::getBytes));
}
 
inline void BinaryWriter::writeFloat32LE(float value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(float));
}
 
inline void BinaryWriter::writeFloat64LE(double value)
{
    LE::getBytes(value, m_buffer);
    m_stream->write(m_buffer, sizeof(double));
}
 
inline void BinaryWriter::writeString(const std::string &value)
{
    m_stream->write(value.data(), static_cast<std::streamsize>(value.size()));
}
 
inline void BinaryWriter::writeTerminatedString(const std::string &value)
{
    m_stream->write(value.data(), static_cast<std::streamsize>(value.size() + 1));
}
 
inline void BinaryWriter::writeLengthPrefixedString(const std::string &value)
{
    writeVariableLengthUIntBE(value.size());
    m_stream->write(value.data(), static_cast<std::streamsize>(value.size()));
}
 
inline void BinaryWriter::writeLengthPrefixedCString(const char *value, std::size_t size)
{
    writeVariableLengthUIntBE(size);
    m_stream->write(value, static_cast<std::streamsize>(size));
}
 
inline void BinaryWriter::writeSynchsafeUInt32BE(std::uint32_t valueToConvertAndWrite)
{
    writeUInt32BE(toSynchsafeInt(valueToConvertAndWrite));
}
 
inline void BinaryWriter::writeFixed8BE(float valueToConvertAndWrite)
{
    writeUInt16BE(toFixed8(valueToConvertAndWrite));
}
 
inline void BinaryWriter::writeFixed16BE(float valueToConvertAndWrite)
{
    writeUInt32BE(toFixed16(valueToConvertAndWrite));
}
 
inline void BinaryWriter::writeSynchsafeUInt32LE(std::uint32_t valueToConvertAndWrite)
{
    writeUInt32LE(toSynchsafeInt(valueToConvertAndWrite));
}
 
inline void BinaryWriter::writeFixed8LE(float valueToConvertAndWrite)
{
    writeUInt16LE(toFixed8(valueToConvertAndWrite));
}
 
inline void BinaryWriter::writeFixed16LE(float valueToConvertAndWrite)
{
    writeUInt32LE(toFixed16(valueToConvertAndWrite));
}
 
inline void BinaryWriter::write(char oneChar)
{
    writeChar(oneChar);
}
 
inline void BinaryWriter::write(std::uint8_t oneByte)
{
    writeByte(oneByte);
}
 
inline void BinaryWriter::write(bool oneBool)
{
    writeBool(oneBool);
}
 
inline void BinaryWriter::write(const std::string &lengthPrefixedString)
{
    writeLengthPrefixedString(lengthPrefixedString);
}
 
inline void BinaryWriter::write(std::string_view lengthPrefixedString)
{
    writeLengthPrefixedCString(lengthPrefixedString.data(), lengthPrefixedString.size());
}
 
inline void BinaryWriter::write(const char *lengthPrefixedString)
{
    writeLengthPrefixedCString(lengthPrefixedString, std::strlen(lengthPrefixedString));
}
 
inline void BinaryWriter::write(std::int16_t one16BitInt)
{
    writeInt16BE(one16BitInt);
}
 
inline void BinaryWriter::write(std::uint16_t one16BitUint)
{
    writeUInt16BE(one16BitUint);
}
 
inline void BinaryWriter::write(std::int32_t one32BitInt)
{
    writeInt32BE(one32BitInt);
}
 
inline void BinaryWriter::write(std::uint32_t one32BitUint)
{
    writeUInt32BE(one32BitUint);
}
 
inline void BinaryWriter::write(std::int64_t one64BitInt)
{
    writeInt64BE(one64BitInt);
}
 
inline void BinaryWriter::write(std::uint64_t one64BitUint)
{
    writeUInt64BE(one64BitUint);
}
 
inline void BinaryWriter::write(float one32BitFloat)
{
    writeFloat32BE(one32BitFloat);
}
 
inline void BinaryWriter::write(double one64BitFloat)
{
    writeFloat64BE(one64BitFloat);
}
} // namespace CppUtilities
 
#endif // IO_UTILITIES_BINARYWRITER_H