diff options
Diffstat (limited to 'common/substream.h')
-rw-r--r-- | common/substream.h | 129 |
1 files changed, 129 insertions, 0 deletions
diff --git a/common/substream.h b/common/substream.h new file mode 100644 index 0000000000..cf794cfa7e --- /dev/null +++ b/common/substream.h @@ -0,0 +1,129 @@ +/* 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. + * + * $URL$ + * $Id$ + * + */ + +#ifndef COMMON_SUBSTREAM_H +#define COMMON_SUBSTREAM_H + +#include "common/stream.h" + +namespace Common { + +/** + * SubReadStream provides access to a ReadStream restricted to the range + * [currentPosition, currentPosition+end). + * + * Manipulating the parent stream directly /will/ mess up a substream. + * Likewise, manipulating two substreams of a parent stream will cause them to + * step on each others toes. + */ +class SubReadStream : virtual public ReadStream { +protected: + ReadStream *_parentStream; + DisposeAfterUse::Flag _disposeParentStream; + uint32 _pos; + uint32 _end; + bool _eos; +public: + SubReadStream(ReadStream *parentStream, uint32 end, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::NO) + : _parentStream(parentStream), + _disposeParentStream(disposeParentStream), + _pos(0), + _end(end), + _eos(false) { + assert(parentStream); + } + ~SubReadStream() { + if (_disposeParentStream) + delete _parentStream; + } + + virtual bool eos() const { return _eos; } + virtual bool err() const { return _parentStream->err(); } + virtual void clearErr() { _eos = false; _parentStream->clearErr(); } + virtual uint32 read(void *dataPtr, uint32 dataSize); +}; + +/* + * SeekableSubReadStream provides access to a SeekableReadStream restricted to + * the range [begin, end). + * The same caveats apply to SeekableSubReadStream as do to SeekableReadStream. + * + * Manipulating the parent stream directly /will/ mess up a substream. + * @see SubReadStream + */ +class SeekableSubReadStream : public SubReadStream, public SeekableReadStream { +protected: + SeekableReadStream *_parentStream; + uint32 _begin; +public: + SeekableSubReadStream(SeekableReadStream *parentStream, uint32 begin, uint32 end, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::NO); + + virtual int32 pos() const { return _pos - _begin; } + virtual int32 size() const { return _end - _begin; } + + virtual bool seek(int32 offset, int whence = SEEK_SET); +}; + +/** + * This is a wrapper around SeekableSubReadStream, but it adds non-endian + * read methods whose endianness is set on the stream creation. + * + * Manipulating the parent stream directly /will/ mess up a substream. + * @see SubReadStream + */ +class SeekableSubReadStreamEndian : public SeekableSubReadStream { +private: + const bool _bigEndian; + +public: + SeekableSubReadStreamEndian(SeekableReadStream *parentStream, uint32 begin, uint32 end, bool bigEndian = false, DisposeAfterUse::Flag disposeParentStream = DisposeAfterUse::NO) + : SeekableSubReadStream(parentStream, begin, end, disposeParentStream), _bigEndian(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); + } + + FORCEINLINE int16 readSint16() { + return (int16)readUint16(); + } + + FORCEINLINE int32 readSint32() { + return (int32)readUint32(); + } +}; + + +} // End of namespace Common + +#endif |