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 */