binaryreader.h

Go to the documentation of this file.

#ifndef IOUTILITIES_BINERYREADER_H
#define IOUTILITIES_BINERYREADER_H
 
#include "../conversion/binaryconversion.h"
 
#include <istream>
#include <string>
#include <vector>
 
namespace CppUtilities {
class CPP_UTILITIES_EXPORT BinaryReader {
 
public:
    BinaryReader(std::istream *stream, bool giveOwnership = false);
    BinaryReader(const BinaryReader &other);
    BinaryReader &operator=(const BinaryReader &rhs) = delete;
    ~BinaryReader();
 
    const std::istream *stream() const;
    std::istream *stream();
    void setStream(std::istream *stream, bool giveOwnership = false);
    bool hasOwnership() const;
    void giveOwnership();
    void detatchOwnership();
    bool fail() const;
    bool eof() const;
    bool canRead() const;
    std::istream::pos_type readStreamsize();
    std::istream::pos_type readRemainingBytes();
    void read(char *buffer, std::streamsize length);
    void read(std::uint8_t *buffer, std::streamsize length);
    void read(std::vector<char> &buffer, std::streamsize length);
    std::int16_t readInt16BE();
    std::uint16_t readUInt16BE();
    std::int32_t readInt24BE();
    std::uint32_t readUInt24BE();
    std::int32_t readInt32BE();
    std::uint32_t readUInt32BE();
    std::int64_t readInt40BE();
    std::uint64_t readUInt40BE();
    std::int64_t readInt56BE();
    std::uint64_t readUInt56BE();
    std::int64_t readInt64BE();
    std::uint64_t readUInt64BE();
    std::uint64_t readVariableLengthUIntBE();
    float readFloat32BE();
    double readFloat64BE();
    std::int16_t readInt16LE();
    std::uint16_t readUInt16LE();
    std::int32_t readInt24LE();
    std::uint32_t readUInt24LE();
    std::int32_t readInt32LE();
    std::uint32_t readUInt32LE();
    std::int64_t readInt40LE();
    std::uint64_t readUInt40LE();
    std::int64_t readInt56LE();
    std::uint64_t readUInt56LE();
    std::int64_t readInt64LE();
    std::uint64_t readUInt64LE();
    std::uint64_t readVariableLengthUIntLE();
    float readFloat32LE();
    double readFloat64LE();
    char readChar();
    std::uint8_t readByte();
    bool readBool();
    std::string readLengthPrefixedString();
    std::string readString(std::size_t length);
    std::string readTerminatedString(std::uint8_t termination = 0);
    std::string readTerminatedString(std::size_t maxBytesToRead, std::uint8_t termination = 0);
    std::uint32_t readSynchsafeUInt32BE();
    float readFixed8BE();
    float readFixed16BE();
    std::uint32_t readSynchsafeUInt32LE();
    float readFixed8LE();
    float readFixed16LE();
    std::uint32_t readCrc32(std::size_t length);
    static std::uint32_t computeCrc32(const char *buffer, std::size_t length);
    static const std::uint32_t crc32Table[];
 
    // declare further overloads for read() to ease use of BinaryReader in templates
    void read(char &oneCharacter);
    void read(std::uint8_t &oneByte);
    void read(bool &oneBool);
    void read(std::string &lengthPrefixedString);
    void read(std::int16_t &one16BitInt);
    void read(std::uint16_t &one16BitUInt);
    void read(std::int32_t &one32BitInt);
    void read(std::uint32_t &one32BitUInt);
    void read(std::int64_t &one64BitInt);
    void read(std::uint64_t &one64BitUInt);
    void read(float &one32BitFloat);
    void read(double &one64BitFloat);
 
private:
    void bufferVariableLengthInteger();
 
    std::istream *m_stream;
    bool m_ownership;
    char m_buffer[8];
};
 
inline BinaryReader::BinaryReader(std::istream *stream, bool giveOwnership)
    : m_stream(stream)
    , m_ownership(giveOwnership)
{
}
 
inline BinaryReader::BinaryReader(const BinaryReader &other)
    : m_stream(other.m_stream)
    , m_ownership(false)
{
}
 
inline BinaryReader::~BinaryReader()
{
    if (m_ownership) {
        delete m_stream;
    }
}
 
inline std::istream *BinaryReader::stream()
{
    return m_stream;
}
 
inline const std::istream *BinaryReader::stream() const
{
    return m_stream;
}
 
inline bool BinaryReader::hasOwnership() const
{
    return m_ownership;
}
 
inline void BinaryReader::giveOwnership()
{
    if (m_stream) {
        m_ownership = true;
    }
}
 
inline void BinaryReader::detatchOwnership()
{
    m_ownership = false;
}
 
inline bool BinaryReader::fail() const
{
    return m_stream ? m_stream->fail() : false;
}
 
inline bool BinaryReader::eof() const
{
    return m_stream && m_stream->eof();
}
 
inline bool BinaryReader::canRead() const
{
    return m_stream && m_stream->good();
}
 
inline void BinaryReader::read(char *buffer, std::streamsize length)
{
    m_stream->read(buffer, length);
}
 
inline void BinaryReader::read(std::uint8_t *buffer, std::streamsize length)
{
    m_stream->read(reinterpret_cast<char *>(buffer), length);
}
 
inline void BinaryReader::read(std::vector<char> &buffer, std::streamsize length)
{
    buffer.resize(static_cast<std::vector<char>::size_type>(length));
    m_stream->read(buffer.data(), length);
}
 
inline std::int16_t BinaryReader::readInt16BE()
{
    m_stream->read(m_buffer, sizeof(std::int16_t));
    return BE::toInt<std::int16_t>(m_buffer);
}
 
inline std::uint16_t BinaryReader::readUInt16BE()
{
    m_stream->read(m_buffer, sizeof(std::uint16_t));
    return BE::toInt<std::uint16_t>(m_buffer);
}
 
inline std::int32_t BinaryReader::readInt24BE()
{
    *m_buffer = 0;
    m_stream->read(m_buffer + 1, 3);
    auto val = BE::toInt<std::int32_t>(m_buffer);
    if (val >= 0x800000) {
        val = -(0x1000000 - val);
    }
    return val;
}
 
inline std::uint32_t BinaryReader::readUInt24BE()
{
    *m_buffer = 0;
    m_stream->read(m_buffer + 1, 3);
    return BE::toInt<std::uint32_t>(m_buffer);
}
 
inline std::int32_t BinaryReader::readInt32BE()
{
    m_stream->read(m_buffer, sizeof(std::int32_t));
    return BE::toInt<std::int32_t>(m_buffer);
}
 
inline std::uint32_t BinaryReader::readUInt32BE()
{
    m_stream->read(m_buffer, sizeof(std::uint32_t));
    return BE::toInt<std::uint32_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt40BE()
{
    *m_buffer = *(m_buffer + 1) = *(m_buffer + 2) = 0;
    m_stream->read(m_buffer + 3, 5);
    auto val = BE::toInt<std::int64_t>(m_buffer);
    if (val >= 0x8000000000) {
        val = -(0x10000000000 - val);
    }
    return val;
}
 
inline std::uint64_t BinaryReader::readUInt40BE()
{
    *m_buffer = *(m_buffer + 1) = *(m_buffer + 2) = 0;
    m_stream->read(m_buffer + 3, 5);
    return BE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt56BE()
{
    *m_buffer = 0;
    m_stream->read(m_buffer + 1, 7);
    auto val = BE::toInt<std::int64_t>(m_buffer);
    if (val >= 0x80000000000000) {
        val = -(0x100000000000000 - val);
    }
    return val;
}
 
inline std::uint64_t BinaryReader::readUInt56BE()
{
    *m_buffer = 0;
    m_stream->read(m_buffer + 1, 7);
    return BE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt64BE()
{
    m_stream->read(m_buffer, sizeof(std::int64_t));
    return BE::toInt<std::int64_t>(m_buffer);
}
 
inline std::uint64_t BinaryReader::readUInt64BE()
{
    m_stream->read(m_buffer, sizeof(std::uint64_t));
    return BE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::uint64_t BinaryReader::readVariableLengthUIntBE()
{
    bufferVariableLengthInteger();
    return BE::toInt<std::uint64_t>(m_buffer);
}
 
inline float BinaryReader::readFloat32BE()
{
    m_stream->read(m_buffer, sizeof(float));
    return BE::toFloat32(m_buffer);
}
 
inline double BinaryReader::readFloat64BE()
{
    m_stream->read(m_buffer, sizeof(double));
    return BE::toFloat64(m_buffer);
}
 
inline std::int16_t BinaryReader::readInt16LE()
{
    m_stream->read(m_buffer, sizeof(std::int16_t));
    return LE::toInt<std::int16_t>(m_buffer);
}
 
inline std::uint16_t BinaryReader::readUInt16LE()
{
    m_stream->read(m_buffer, sizeof(std::uint16_t));
    return LE::toInt<std::uint16_t>(m_buffer);
}
 
inline std::int32_t BinaryReader::readInt24LE()
{
    *(m_buffer + 3) = 0;
    m_stream->read(m_buffer, 3);
    auto val = LE::toInt<std::int32_t>(m_buffer);
    if (val >= 0x800000) {
        val = -(0x1000000 - val);
    }
    return val;
}
 
inline std::uint32_t BinaryReader::readUInt24LE()
{
    *(m_buffer + 3) = 0;
    m_stream->read(m_buffer, 3);
    return LE::toInt<std::uint32_t>(m_buffer);
}
 
inline std::int32_t BinaryReader::readInt32LE()
{
    m_stream->read(m_buffer, sizeof(std::int32_t));
    return LE::toInt<std::int32_t>(m_buffer);
}
 
inline std::uint32_t BinaryReader::readUInt32LE()
{
    m_stream->read(m_buffer, sizeof(std::uint32_t));
    return LE::toInt<std::uint32_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt40LE()
{
    *(m_buffer + 5) = *(m_buffer + 6) = *(m_buffer + 7) = 0;
    m_stream->read(m_buffer, 5);
    auto val = LE::toInt<std::int64_t>(m_buffer);
    if (val >= 0x8000000000) {
        val = -(0x10000000000 - val);
    }
    return val;
}
 
inline std::uint64_t BinaryReader::readUInt40LE()
{
    *(m_buffer + 5) = *(m_buffer + 6) = *(m_buffer + 7) = 0;
    m_stream->read(m_buffer, 5);
    return LE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt56LE()
{
    *(m_buffer + 7) = 0;
    m_stream->read(m_buffer, 7);
    auto val = LE::toInt<std::int64_t>(m_buffer);
    if (val >= 0x80000000000000) {
        val = -(0x100000000000000 - val);
    }
    return val;
}
 
inline std::uint64_t BinaryReader::readUInt56LE()
{
    *(m_buffer + 7) = 0;
    m_stream->read(m_buffer, 7);
    return LE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::int64_t BinaryReader::readInt64LE()
{
    m_stream->read(m_buffer, sizeof(std::int64_t));
    return LE::toInt<std::int64_t>(m_buffer);
}
 
inline std::uint64_t BinaryReader::readUInt64LE()
{
    m_stream->read(m_buffer, sizeof(std::uint64_t));
    return LE::toInt<std::uint64_t>(m_buffer);
}
 
inline std::uint64_t BinaryReader::readVariableLengthUIntLE()
{
    bufferVariableLengthInteger();
    return LE::toInt<std::uint64_t>(m_buffer);
}
 
inline float BinaryReader::readFloat32LE()
{
    m_stream->read(m_buffer, sizeof(float));
    return LE::toFloat32(m_buffer);
}
 
inline double BinaryReader::readFloat64LE()
{
    m_stream->read(m_buffer, sizeof(double));
    return LE::toFloat64(m_buffer);
}
 
inline char BinaryReader::readChar()
{
    m_stream->read(m_buffer, sizeof(char));
    return m_buffer[0];
}
 
inline uint8_t BinaryReader::readByte()
{
    m_stream->read(m_buffer, sizeof(char));
    return static_cast<std::uint8_t>(m_buffer[0]);
}
 
inline bool BinaryReader::readBool()
{
    return readByte() != 0;
}
 
inline std::string BinaryReader::readLengthPrefixedString()
{
    return readString(readVariableLengthUIntBE());
}
 
inline std::uint32_t BinaryReader::readSynchsafeUInt32BE()
{
    return toNormalInt(readUInt32BE());
}
 
inline float BinaryReader::readFixed8BE()
{
    return toFloat32(readUInt16BE());
}
 
inline float BinaryReader::readFixed16BE()
{
    return toFloat32(readUInt32BE());
}
 
inline std::uint32_t BinaryReader::readSynchsafeUInt32LE()
{
    return toNormalInt(readUInt32LE());
}
 
inline float BinaryReader::readFixed8LE()
{
    return toFloat32(readUInt16LE());
}
 
inline float BinaryReader::readFixed16LE()
{
    return toFloat32(readUInt32LE());
}
 
inline void BinaryReader::read(char &oneCharacter)
{
    oneCharacter = readChar();
}
 
inline void BinaryReader::read(std::uint8_t &oneByte)
{
    oneByte = readByte();
}
 
inline void BinaryReader::read(bool &oneBool)
{
    oneBool = readBool();
}
 
inline void BinaryReader::read(std::string &lengthPrefixedString)
{
    lengthPrefixedString = readLengthPrefixedString();
}
 
inline void BinaryReader::read(std::int16_t &one16BitInt)
{
    one16BitInt = readInt16BE();
}
 
inline void BinaryReader::read(std::uint16_t &one16BitUInt)
{
    one16BitUInt = readUInt16BE();
}
 
inline void BinaryReader::read(std::int32_t &one32BitInt)
{
    one32BitInt = readInt32BE();
}
 
inline void BinaryReader::read(std::uint32_t &one32BitUInt)
{
    one32BitUInt = readUInt32BE();
}
 
inline void BinaryReader::read(std::int64_t &one64BitInt)
{
    one64BitInt = readInt64BE();
}
 
inline void BinaryReader::read(std::uint64_t &one64BitUInt)
{
    one64BitUInt = readUInt64BE();
}
 
inline void BinaryReader::read(float &one32BitFloat)
{
    one32BitFloat = readFloat32BE();
}
 
inline void BinaryReader::read(double &one64BitFloat)
{
    one64BitFloat = readFloat64BE();
}
} // namespace CppUtilities
 
#endif // IOUTILITIES_BINERYREADER_H