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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#ifndef COMMON_STREAM_H
#define COMMON_STREAM_H

#include "common/endian.h"
#include "common/scummsys.h"
#include "common/str.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 int32 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);
    }

    uint32 writeStream(ReadStream *stream, uint32 dataSize);
    uint32 writeStream(SeekableReadStream *stream);

    void writeString(const String &str);
};

class SeekableWriteStream : public WriteStream {
public:
    virtual bool seek(int32 offset, int whence = SEEK_SET) = 0;

    virtual int32 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() {
        uint32 n = readUint32LE();
        float f;

        memcpy(&f, &n, 4);

        return f;
    }

    FORCEINLINE float readFloatBE() {
        uint32 n = readUint32BE();
        float f;

        memcpy(&f, &n, 4);

        return f;
    }


    FORCEINLINE double readDoubleLE() {
        uint64 n = readUint64LE();
        double d;

        memcpy(&d, &n, 8);

        return d;
    }

    FORCEINLINE double readDoubleBE() {
        uint64 n = readUint64BE();
        double d;

        memcpy(&d, &n, 8);

        return d;
    }

    SeekableReadStream *readStream(uint32 dataSize);

    Common::String readPascalString(bool transformCR = true);
};

class SeekableReadStream : virtual public ReadStream {
public:

    virtual int32 pos() const = 0;

    virtual int32 size() const = 0;

    virtual bool seek(int32 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) ? TO_BE_16(val) : TO_LE_16(val);
    }
    uint32 readUint32() {
        uint32 val;
        read(&val, 4);
        return (_bigEndian) ? TO_BE_32(val) : TO_LE_32(val);
    }
    uint64 readUint64() {
        uint64 val;
        read(&val, 8);
        return (_bigEndian) ? TO_BE_64(val) : TO_LE_64(val);
    }
    FORCEINLINE int16 readSint16() {
        return (int16)readUint16();
    }
    FORCEINLINE int32 readSint32() {
        return (int32)readUint32();
    }
    FORCEINLINE int64 readSint64() {
        return (int64)readUint64();
    }
};

class SeekableReadStreamEndian : virtual public SeekableReadStream, virtual public ReadStreamEndian {
public:
    SeekableReadStreamEndian(bool bigEndian) : ReadStreamEndian(bigEndian) {}
};

} // End of namespace Common

#endif