simple_file.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 TITANIC_SIMPLE_FILE_H
#define TITANIC_SIMPLE_FILE_H

#include "common/file.h"
#include "titanic/support/rect.h"
#include "common/savefile.h"
#include "common/stream.h"
#include "common/compression/deflate.h"
#include "titanic/support/string.h"

namespace Titanic {

class Decompressor;
class DecompressorData;

class File : public Common::File {
public:
    bool open(const Common::Path &filename) override;
};

class SimpleFile {
private:
    void skipSpaces();
protected:
    Common::SeekableReadStream *_inStream;
    Common::OutSaveFile *_outStream;
    int _lineCount;
public:
    SimpleFile();
    virtual ~SimpleFile();

    operator Common::SeekableReadStream &() { return *_inStream; }
    operator Common::WriteStream &() { return *_outStream; }

    virtual void open(Common::SeekableReadStream *stream);

    virtual void open(Common::OutSaveFile *stream);

    virtual void close();

    virtual void safeRead(void *dst, size_t count);

    virtual size_t unsafeRead(void *dst, size_t count);

    virtual size_t write(const void *src, size_t count) const;

    virtual void seek(int offset, int origin);
    byte readByte();

    uint readUint16LE();

    uint readUint32LE();

    CString readString();

    int readNumber();

    double readFloat();

    Point readPoint();

    Rect readRect();

    Rect readBounds();

    void readBuffer(char *buffer = nullptr, size_t count = 0);

    bool scanf(const char *format, ...);

    void writeByte(byte b) { write(&b, 1); }

    void writeUint16LE(uint val);

    void writeUint32LE(uint val);

    void writeLine(const CString &str) const;

    void writeString(const CString &str) const;

    void writeQuotedString(const CString &str) const;

    void writeQuotedLine(const CString &str, int indent) const;

    void writeNumber(int val) const;

    void writeNumberLine(int val, int indent) const;

    void writeFloat(double val) const;

    void writeFloatLine(double val, int indent) const;

    void writePoint(const Point &pt, int indent)const;

    void writeRect(const Rect &r, int indent) const;

    void writeBounds(const Rect &r, int indent) const;

    void writeFormat(const char *format, ...) const;

    void writeIndent(uint indent) const;

    bool isClassStart();

    void writeClassStart(const CString &classStr, int indent);

    void writeClassEnd(int indent);

    bool eos() const {
        assert(_inStream);
        return _inStream->pos() >= _inStream->size();
    }
};

class CompressedFile : public SimpleFile {
public:
    CompressedFile() : SimpleFile() {}
    ~CompressedFile() override {}

    void open(Common::SeekableReadStream *stream) override {
        SimpleFile::open(Common::wrapCompressedReadStream(stream));
    }

    void open(Common::OutSaveFile *stream) override {
        SimpleFile::open(new Common::OutSaveFile(Common::wrapCompressedWriteStream(stream)));
    }
};

class StdCWadFile : public SimpleFile {
public:
    StdCWadFile() : SimpleFile() {}
    ~StdCWadFile() override {}

    virtual bool open(const Common::String &filename);

    void open(Common::SeekableReadStream *stream) override {}

    void open(Common::OutSaveFile *stream) override {}

    Common::SeekableReadStream *readStream() const { return _inStream; }
};

CString readStringFromStream(Common::SeekableReadStream *s);

} // End of namespace Titanic

#endif /* TITANIC_SIMPLE_FILE_H */