stream.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef COMMON_STREAM_H
#define COMMON_STREAM_H
 
#include "common/endian.h"
#include "common/ptr.h"
#include "common/scummsys.h"
#include "common/str.h"
#include "common/data-io.h"
 
namespace Common {
 
class ReadStream;
class SeekableReadStream;
 
class Stream {
public:
    virtual ~Stream() {}
 
    virtual bool err() const { return false; }
 
    virtual void clearErr() {}
};
 
class WriteStream : virtual public Stream {
public:
    virtual uint32 write(const void *dataPtr, uint32 dataSize) = 0;
 
    virtual bool flush() { return true; }
 
    virtual void finalize() {
        flush();
    }
 
    virtual int64 pos() const = 0;
 
    void writeByte(byte value) {
        write(&value, 1);
    }
    void writeSByte(int8 value) {
        write(&value, 1);
    }
    void writeUint16LE(uint16 value) {
        value = TO_LE_16(value);
        write(&value, 2);
    }
    void writeUint32LE(uint32 value) {
        value = TO_LE_32(value);
        write(&value, 4);
    }
    void writeUint64LE(uint64 value) {
        value = TO_LE_64(value);
        write(&value, 8);
    }
    void writeUint16BE(uint16 value) {
        value = TO_BE_16(value);
        write(&value, 2);
    }
    void writeUint32BE(uint32 value) {
        value = TO_BE_32(value);
        write(&value, 4);
    }
    void writeUint64BE(uint64 value) {
        value = TO_BE_64(value);
        write(&value, 8);
    }
    FORCEINLINE void writeSint16LE(int16 value) {
        writeUint16LE((uint16)value);
    }
    FORCEINLINE void writeSint32LE(int32 value) {
        writeUint32LE((uint32)value);
    }
    FORCEINLINE void writeSint64LE(int64 value) {
        writeUint64LE((uint64)value);
    }
    FORCEINLINE void writeSint16BE(int16 value) {
        writeUint16BE((uint16)value);
    }
    FORCEINLINE void writeSint32BE(int32 value) {
        writeUint32BE((uint32)value);
    }
    FORCEINLINE void writeSint64BE(int64 value) {
        writeUint64BE((uint64)value);
    }
 
 
    FORCEINLINE void writeFloatLE(float value) {
        uint32 n;
 
        memcpy(&n, &value, 4);
 
        writeUint32LE(n);
    }
 
 
    FORCEINLINE void writeFloatBE(float value) {
        uint32 n;
 
        memcpy(&n, &value, 4);
 
        writeUint32BE(n);
    }
 
    FORCEINLINE void writeDoubleLE(double value) {
        uint64 n;
 
        memcpy(&n, &value, 8);
 
        writeUint64LE(n);
    }
 
 
    FORCEINLINE void writeDoubleBE(double value) {
        uint64 n;
 
        memcpy(&n, &value, 8);
 
        writeUint64BE(n);
    }
 
    template<class TDataFormat, class... T>
    bool writeMultiple(const TDataFormat &dataFormat, const T &...values) {
        const TDataFormat dataFormatCopy = dataFormat; // Copy to help compiler alias analysis, parameter is const ref to ensure TDataFormat is a concrete type
 
        byte buffer[DataMultipleIO<TDataFormat, T...>::kMaxSize];
        const uint actualSize = DataMultipleIO<TDataFormat, T...>::computeSize(dataFormatCopy);
 
        DataMultipleIO<TDataFormat, T...>::encode(dataFormatCopy, buffer, values...);
 
        if (this->write(buffer, actualSize) != actualSize)
            return false;
 
        return true;
    }
 
    template<class... T>
    inline bool writeMultipleEndian(bool isLittle, const T &...values) {
        return this->writeMultiple<EndianStorageFormat, T...>(isLittle ? EndianStorageFormat::Little : EndianStorageFormat::Big, values...);
    }
 
    template<class... T>
    inline bool writeMultipleLE(const T &...values) {
        return this->writeMultiple<EndianStorageFormat, T...>(EndianStorageFormat::Little, values...);
    }
 
    template<class... T>
    inline bool writeMultipleBE(const T &...values) {
        return this->writeMultiple<EndianStorageFormat, T...>(EndianStorageFormat::Big, values...);
    }
 
    uint32 writeStream(ReadStream *stream, uint32 dataSize);
    uint32 writeStream(ReadStream *stream);
 
    void writeString(const String &str);
};
 
class SeekableWriteStream : public WriteStream {
public:
    virtual bool seek(int64 offset, int whence = SEEK_SET) = 0;
 
    virtual int64 size() const = 0;
};
 
class ReadStream : virtual public Stream {
public:
    ReadStream() {}
 
    virtual bool eos() const = 0;
 
    virtual uint32 read(void *dataPtr, uint32 dataSize) = 0;
 
    byte readByte() {
        byte b = 0; // FIXME: remove initialisation
        read(&b, 1);
        return b;
    }
 
    FORCEINLINE int8 readSByte() {
        return (int8)readByte();
    }
 
    uint16 readUint16LE() {
        uint16 val;
        read(&val, 2);
        return FROM_LE_16(val);
    }
 
    uint32 readUint32LE() {
        uint32 val;
        read(&val, 4);
        return FROM_LE_32(val);
    }
 
    uint64 readUint64LE() {
        uint64 val;
        read(&val, 8);
        return FROM_LE_64(val);
    }
 
    uint16 readUint16BE() {
        uint16 val;
        read(&val, 2);
        return FROM_BE_16(val);
    }
 
    uint32 readUint32BE() {
        uint32 val;
        read(&val, 4);
        return FROM_BE_32(val);
    }
 
    uint64 readUint64BE() {
        uint64 val;
        read(&val, 8);
        return FROM_BE_64(val);
    }
 
    FORCEINLINE int16 readSint16LE() {
        return (int16)readUint16LE();
    }
 
    FORCEINLINE int32 readSint32LE() {
        return (int32)readUint32LE();
    }
 
    FORCEINLINE int64 readSint64LE() {
        return (int64)readUint64LE();
    }
 
    FORCEINLINE int16 readSint16BE() {
        return (int16)readUint16BE();
    }
 
    FORCEINLINE int32 readSint32BE() {
        return (int32)readUint32BE();
    }
 
    FORCEINLINE int64 readSint64BE() {
        return (int64)readUint64BE();
    }
 
    FORCEINLINE float readFloatLE() {
        uint8 val[4];
        read(val, 4);
        return READ_LE_FLOAT32(val);
    }
 
    FORCEINLINE float readFloatBE() {
        uint8 val[4];
        read(val, 4);
        return READ_BE_FLOAT32(val);
    }
 
 
    FORCEINLINE double readDoubleLE() {
        uint8 val[8];
        read(val, 8);
        return READ_LE_FLOAT64(val);
    }
 
    FORCEINLINE double readDoubleBE() {
        uint8 val[8];
        read(val, 8);
        return READ_BE_FLOAT64(val);
    }
 
    template<class TDataFormat, class... T>
    bool readMultiple(const TDataFormat &dataFormat, T &...values) {
        const TDataFormat dataFormatCopy = dataFormat;  // Copy to help compiler alias analysis, parameter is const ref to ensure TDataFormat is a concrete type
 
        byte buffer[DataMultipleIO<TDataFormat, T...>::kMaxSize];
        const uint actualSize = DataMultipleIO<TDataFormat, T...>::computeSize(dataFormatCopy);
 
        if (read(buffer, actualSize) != actualSize)
            return false;
 
        DataMultipleIO<TDataFormat, T...>::decode(dataFormatCopy, buffer, values...);
        return true;
    }
 
    template<class... T>
    inline bool readMultipleEndian(bool isLittle, T &...values) {
        return this->readMultiple<EndianStorageFormat, T...>(isLittle ? EndianStorageFormat::Little : EndianStorageFormat::Big, values...);
    }
 
    template<class... T>
    inline bool readMultipleLE(T &...values) {
        return this->readMultiple<EndianStorageFormat, T...>(EndianStorageFormat::Little, values...);
    }
 
    template<class... T>
    inline bool readMultipleBE(T &...values) {
        return this->readMultiple<EndianStorageFormat, T...>(EndianStorageFormat::Big, values...);
    }
 
    SeekableReadStream *readStream(uint32 dataSize);
 
    String readString(char terminator = 0, size_t len = String::npos);
 
    Common::String readPascalString(bool transformCR = true);
};
 
class SeekableReadStream : virtual public ReadStream {
public:
 
    virtual int64 pos() const = 0;
 
    virtual int64 size() const = 0;
 
    virtual bool seek(int64 offset, int whence = SEEK_SET) = 0;
 
    virtual bool skip(uint32 offset) { return seek(offset, SEEK_CUR); }
 
    virtual char *readLine(char *s, size_t bufSize, bool handleCR = true);
 
 
    virtual String readLine(bool handleCR = true);
 
    void hexdump(int len, int bytesPerLine = 16, int startOffset = 0);
};
 
class ReadStreamEndian : virtual public ReadStream {
private:
    const bool _bigEndian;
 
public:
    ReadStreamEndian(bool bigEndian) : _bigEndian(bigEndian) {}
    bool isBE() const { return _bigEndian; }
    uint16 readUint16() {
        uint16 val;
        read(&val, 2);
        return (_bigEndian) ? FROM_BE_16(val) : FROM_LE_16(val);
    }
    uint32 readUint32() {
        uint32 val;
        read(&val, 4);
        return (_bigEndian) ? FROM_BE_32(val) : FROM_LE_32(val);
    }
    uint64 readUint64() {
        uint64 val;
        read(&val, 8);
        return (_bigEndian) ? FROM_BE_64(val) : FROM_LE_64(val);
    }
    FORCEINLINE int16 readSint16() {
        return (int16)readUint16();
    }
    FORCEINLINE int32 readSint32() {
        return (int32)readUint32();
    }
    FORCEINLINE int64 readSint64() {
        return (int64)readUint64();
    }
 
    FORCEINLINE float readFloat() {
        uint8 val[4];
        read(val, 4);
        return (_bigEndian) ? READ_BE_FLOAT32(val) : READ_LE_FLOAT32(val);
    }
 
    FORCEINLINE double readDouble() {
        uint8 val[8];
        read(val, 8);
        return (_bigEndian) ? READ_BE_FLOAT64(val) : READ_LE_FLOAT64(val);
    }
};
 
class SeekableReadStreamEndian : virtual public SeekableReadStream, virtual public ReadStreamEndian {
public:
    SeekableReadStreamEndian(bool bigEndian) : ReadStreamEndian(bigEndian) {}
};
 
class SeekableReadStreamEndianWrapper final : virtual public SeekableReadStreamEndian {
protected:
    DisposablePtr<SeekableReadStream> _parentStream;
 
public:
    SeekableReadStreamEndianWrapper(SeekableReadStream *parentStream, bool bigEndian, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::NO)
        : SeekableReadStreamEndian(bigEndian),
          ReadStreamEndian(bigEndian),
          _parentStream(parentStream, disposeParentStream) {
        assert(parentStream);
    }
 
    /* Stream APIs */
    bool err() const override { return _parentStream->err(); }
    void clearErr() override { _parentStream->clearErr(); }
 
    /* ReadStream APIs */
    bool eos() const override { return _parentStream->eos(); }
    uint32 read(void *dataPtr, uint32 dataSize) override { return _parentStream->read(dataPtr, dataSize); }
 
    /* SeekableReadStream APIs */
    int64 pos() const override { return _parentStream->pos(); }
    int64 size() const override { return _parentStream->size(); }
    bool seek(int64 offset, int whence = SEEK_SET) override { return _parentStream->seek(offset, whence); }
};
 
} // End of namespace Common
 
#endif