OgreStreamSerialiser.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __StreamSerialiser_H__
29 #define __StreamSerialiser_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreDataStream.h"
33 #include "OgreHeaderPrefix.h"
34 
35 namespace Ogre
36 {
67  {
68  public:
70  enum Endian
71  {
77  ENDIAN_LITTLE
78  };
79 
82  {
86  REAL_DOUBLE
87  };
88 
89 
91  struct Chunk : public StreamAlloc
92  {
101 
102  Chunk() : id(0), version(1), length(0), offset(0) {}
103  };
104 
122  StreamSerialiser(const DataStreamPtr& stream, Endian endianMode = ENDIAN_AUTO,
123  bool autoHeader = true,
125  RealStorageFormat realFormat = REAL_DOUBLE
126 #else
127  RealStorageFormat realFormat = REAL_FLOAT
128 #endif
129  );
130  virtual ~StreamSerialiser();
131 
137  virtual Endian getEndian() const { return mEndian; }
138 
145  static uint32 makeIdentifier(const String& code);
146 
153  size_t getCurrentChunkDepth() const { return mChunkStack.size(); }
154 
160 
168  size_t getOffsetFromChunkStart() const;
169 
181  virtual const Chunk* readChunkBegin();
182 
195  virtual const Chunk* readChunkBegin(uint32 id, uint16 maxVersion, const String& msg = StringUtil::BLANK);
196 
206  virtual void undoReadChunk(uint32 id);
207 
210 
219  virtual void readChunkEnd(uint32 id);
220 
224  virtual bool isEndOfChunk(uint32 id);
225 
227  virtual bool eof() const;
228 
230  virtual const Chunk* getCurrentChunk() const;
231 
246  virtual void writeChunkBegin(uint32 id, uint16 version = 1);
251  virtual void writeChunkEnd(uint32 id);
252 
259  virtual void writeData(const void* buf, size_t size, size_t count);
260 
262  template <typename T>
263  void write(const T* pT, size_t count = 1)
264  {
265  writeData(pT, sizeof(T), count);
266  }
267 
268  // Special-case Real since we need to deal with single/double precision
269  virtual void write(const Real* val, size_t count = 1);
270 
271  virtual void write(const Vector2* vec, size_t count = 1);
272  virtual void write(const Vector3* vec, size_t count = 1);
273  virtual void write(const Vector4* vec, size_t count = 1);
274  virtual void write(const Quaternion* q, size_t count = 1);
275  virtual void write(const Matrix3* m, size_t count = 1);
276  virtual void write(const Matrix4* m, size_t count = 1);
277  virtual void write(const String* string);
278  virtual void write(const AxisAlignedBox* aabb, size_t count = 1);
279  virtual void write(const Sphere* sphere, size_t count = 1);
280  virtual void write(const Plane* plane, size_t count = 1);
281  virtual void write(const Ray* ray, size_t count = 1);
282  virtual void write(const Radian* angle, size_t count = 1);
283  virtual void write(const Node* node, size_t count = 1);
284  virtual void write(const bool* boolean, size_t count = 1);
285 
286 
293  virtual void readData(void* buf, size_t size, size_t count);
294 
296  template <typename T>
297  void read(T* pT, size_t count = 1)
298  {
299  readData(pT, sizeof(T), count);
300  }
301 
302  // Special case Real, single/double-precision issues
303  virtual void read(Real* val, size_t count = 1);
304 
306  virtual void read(Vector2* vec, size_t count = 1);
307  virtual void read(Vector3* vec, size_t count = 1);
308  virtual void read(Vector4* vec, size_t count = 1);
309  virtual void read(Quaternion* q, size_t count = 1);
310  virtual void read(Matrix3* m, size_t count = 1);
311  virtual void read(Matrix4* m, size_t count = 1);
312  virtual void read(String* string);
313  virtual void read(AxisAlignedBox* aabb, size_t count = 1);
314  virtual void read(Sphere* sphere, size_t count = 1);
315  virtual void read(Plane* plane, size_t count = 1);
316  virtual void read(Ray* ray, size_t count = 1);
317  virtual void read(Radian* angle, size_t count = 1);
318  virtual void read(Node* node, size_t count = 1);
319  virtual void read(bool* val, size_t count = 1);
320 
324  virtual void startDeflate(size_t avail_in = 0);
327  virtual void stopDeflate();
328  protected:
338 
342 
343  virtual Chunk* readChunkImpl();
344  virtual void writeChunkImpl(uint32 id, uint16 version);
345  virtual void readHeader();
346  virtual void writeHeader();
348  virtual void checkStream(bool failOnEof = false,
349  bool validateReadable = false, bool validateWriteable = false) const;
350 
351  virtual void flipEndian(void * pData, size_t size, size_t count);
352  virtual void flipEndian(void * pData, size_t size);
353  virtual void determineEndianness();
354  virtual Chunk* popChunk(uint id);
355 
356  virtual void writeFloatsAsDoubles(const float* val, size_t count);
357  virtual void writeDoublesAsFloats(const double* val, size_t count);
358  virtual void readFloatsAsDoubles(double* val, size_t count);
359  virtual void readDoublesAsFloats(float* val, size_t count);
360  template <typename T, typename U>
361  void writeConverted(const T* src, U typeToWrite, size_t count)
362  {
363  U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
364  U* pDst = tmp;
365  const T* pSrc = src;
366  for (size_t i = 0; i < count; ++i)
367  *pDst++ = static_cast<U>(*pSrc++);
368 
369  writeData(tmp, sizeof(U), count);
370 
372  }
373  template <typename T, typename U>
374  void readConverted(T* dst, U typeToRead, size_t count)
375  {
376  U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
377  readData(tmp, sizeof(U), count);
378 
379  T* pDst = dst;
380  const U* pSrc = tmp;
381  for (size_t i = 0; i < count; ++i)
382  *pDst++ = static_cast<T>(*pSrc++);
383 
384 
386  }
387 
388  };
391 }
392 
393 #include "OgreHeaderSuffix.h"
394 
395 #endif
396 
OgreHeaderSuffix.h
Ogre::StreamSerialiser::eof
virtual bool eof() const
Reports whether the stream is at the end of file.
Ogre::StreamSerialiser::~StreamSerialiser
virtual ~StreamSerialiser()
Ogre::StreamSerialiser::write
virtual void write(const Radian *angle, size_t count=1)
Ogre::StreamSerialiser::getOffsetFromChunkStart
size_t getOffsetFromChunkStart() const
Get the current byte position relative to the start of the data section of the last chunk that was re...
Ogre::StreamSerialiser::mRealFormat
RealStorageFormat mRealFormat
Definition: OgreStreamSerialiser.h:334
Ogre::StreamSerialiser::readData
virtual void readData(void *buf, size_t size, size_t count)
Read arbitrary data from a stream.
Ogre::StreamSerialiser::write
virtual void write(const Sphere *sphere, size_t count=1)
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:59
Ogre
Definition: OgreAndroidLogListener.h:35
Ogre::StreamSerialiser::mChunkStack
ChunkStack mChunkStack
Current list of open chunks.
Definition: OgreStreamSerialiser.h:337
Ogre::Plane
Defines a plane in 3D space.
Definition: OgrePlane.h:62
Ogre::StreamSerialiser::write
virtual void write(const Vector4 *vec, size_t count=1)
Ogre::StreamSerialiser::stopDeflate
virtual void stopDeflate()
Stop (un)compressing data.
Ogre::StreamSerialiser::writeHeader
virtual void writeHeader()
Ogre::StreamSerialiser::startDeflate
virtual void startDeflate(size_t avail_in=0)
Start (un)compressing data.
Ogre::StreamSerialiser::checkStream
virtual void checkStream(bool failOnEof=false, bool validateReadable=false, bool validateWriteable=false) const
Ogre::StreamSerialiser::readConverted
void readConverted(T *dst, U typeToRead, size_t count)
Definition: OgreStreamSerialiser.h:374
Ogre::StreamSerialiser::write
virtual void write(const Ray *ray, size_t count=1)
Ogre::StreamSerialiser::read
virtual void read(Sphere *sphere, size_t count=1)
Ogre::StreamSerialiser::RealStorageFormat
RealStorageFormat
The storage format of Real values.
Definition: OgreStreamSerialiser.h:82
OGRE_FREE
#define OGRE_FREE(ptr, category)
Free the memory allocated with OGRE_MALLOC or OGRE_ALLOC_T. Category is required to be restated to en...
Definition: OgreMemoryAllocatorConfig.h:430
Ogre::StreamSerialiser::readFloatsAsDoubles
virtual void readFloatsAsDoubles(double *val, size_t count)
Ogre::StreamSerialiser::writeChunkImpl
virtual void writeChunkImpl(uint32 id, uint16 version)
Ogre::StreamSerialiser::mStream
DataStreamPtr mStream
Definition: OgreStreamSerialiser.h:329
Ogre::StreamSerialiser::read
virtual void read(Quaternion *q, size_t count=1)
Ogre::StreamSerialiser::write
virtual void write(const Real *val, size_t count=1)
Ogre::StreamSerialiser::read
virtual void read(AxisAlignedBox *aabb, size_t count=1)
Ogre::StreamSerialiser::read
void read(T *pT, size_t count=1)
Catch-all method to read primitive types.
Definition: OgreStreamSerialiser.h:297
Ogre::StreamSerialiser::read
virtual void read(Node *node, size_t count=1)
Ogre::Matrix3
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:69
Ogre::StreamSerialiser::getCurrentChunk
virtual const Chunk * getCurrentChunk() const
Get the definition of the current chunk being read (if any).
Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:360
Ogre::StreamSerialiser::writeChunkBegin
virtual void writeChunkBegin(uint32 id, uint16 version=1)
Begin writing a new chunk.
Ogre::StreamSerialiser::readHeader
virtual void readHeader()
Ogre::StreamSerialiser::HEADER_ID
static uint32 HEADER_ID
Definition: OgreStreamSerialiser.h:339
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
OGRE_ALLOC_T
#define OGRE_ALLOC_T(T, count, category)
Allocate a block of memory for a primitive type, and indicate the category of usage.
Definition: OgreMemoryAllocatorConfig.h:428
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::StreamSerialiser::getCurrentChunkID
uint32 getCurrentChunkID() const
Get the ID of the chunk that's currently being read/written, if any.
Ogre::StreamSerialiser::isEndOfChunk
virtual bool isEndOfChunk(uint32 id)
Return whether the current data pointer is at the end of the current chunk.
Ogre::StreamSerialiser::write
virtual void write(const Vector2 *vec, size_t count=1)
Ogre::StreamSerialiser::read
virtual void read(Real *val, size_t count=1)
Ogre::StreamSerialiser::mOriginalStream
DataStreamPtr mOriginalStream
Definition: OgreStreamSerialiser.h:330
Ogre::Quaternion
Implementation of a Quaternion, i.e.
Definition: OgreQuaternion.h:58
Ogre::StreamSerialiser::Chunk::version
uint16 version
Version of the chunk (stored)
Definition: OgreStreamSerialiser.h:96
Ogre::StreamSerialiser::read
virtual void read(Vector4 *vec, size_t count=1)
Ogre::StreamSerialiser::write
virtual void write(const Node *node, size_t count=1)
Ogre::StringUtil::BLANK
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Ogre::StreamSerialiser::ENDIAN_BIG
@ ENDIAN_BIG
Use big endian (0x1000 is serialised as 0x10 0x00)
Definition: OgreStreamSerialiser.h:75
Ogre::StreamSerialiser::makeIdentifier
static uint32 makeIdentifier(const String &code)
Pack a 4-character code into a 32-bit identifier.
OgreHeaderPrefix.h
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
Ogre::StreamSerialiser::popChunk
virtual Chunk * popChunk(uint id)
Ogre::StreamSerialiser::Chunk::offset
uint32 offset
Location of the chunk (header) in bytes from the start of a stream (derived)
Definition: OgreStreamSerialiser.h:100
Ogre::StreamSerialiser::mEndian
Endian mEndian
Definition: OgreStreamSerialiser.h:331
OgrePrerequisites.h
Ogre::StreamSerialiser::peekNextChunkID
virtual uint32 peekNextChunkID()
Call this to 'peek' at the next chunk ID without permanently moving the stream pointer.
Ogre::StreamSerialiser::flipEndian
virtual void flipEndian(void *pData, size_t size)
Ogre::StreamSerialiser::read
virtual void read(Matrix4 *m, size_t count=1)
Ogre::deque
Definition: OgrePrerequisites.h:478
Ogre::StreamSerialiser::mReadWriteHeader
bool mReadWriteHeader
Definition: OgreStreamSerialiser.h:333
Ogre::Radian
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:48
Ogre::StreamSerialiser::writeConverted
void writeConverted(const T *src, U typeToWrite, size_t count)
Definition: OgreStreamSerialiser.h:361
Ogre::StreamSerialiser::read
virtual void read(Vector2 *vec, size_t count=1)
read a Vector3
Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:55
Ogre::StreamSerialiser::StreamSerialiser
StreamSerialiser(const DataStreamPtr &stream, Endian endianMode=ENDIAN_AUTO, bool autoHeader=true, RealStorageFormat realFormat=REAL_FLOAT)
Constructor.
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::StreamSerialiser::Chunk::id
uint32 id
Identifier of the chunk (for example from makeIdentifier) (stored)
Definition: OgreStreamSerialiser.h:94
Ogre::StreamSerialiser::write
virtual void write(const String *string)
Ogre::StreamSerialiser::read
virtual void read(Vector3 *vec, size_t count=1)
Ogre::MEMCATEGORY_GENERAL
@ MEMCATEGORY_GENERAL
General purpose.
Definition: OgreMemoryAllocatorConfig.h:162
Ogre::Sphere
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:52
Ogre::StreamSerialiser::getCurrentChunkDepth
size_t getCurrentChunkDepth() const
Report the current depth of the chunk nesting, whether reading or writing.
Definition: OgreStreamSerialiser.h:153
Ogre::StreamSerialiser::write
void write(const T *pT, size_t count=1)
Catch-all method to write primitive types.
Definition: OgreStreamSerialiser.h:263
Ogre::SharedPtr< DataStream >
Ogre::StreamSerialiser::Chunk
Definition of a chunk of data in a file.
Definition: OgreStreamSerialiser.h:92
Ogre::StreamSerialiser::CHUNK_HEADER_SIZE
static uint32 CHUNK_HEADER_SIZE
Definition: OgreStreamSerialiser.h:341
Ogre::StreamSerialiser::REVERSE_HEADER_ID
static uint32 REVERSE_HEADER_ID
Definition: OgreStreamSerialiser.h:340
Ogre::StreamSerialiser
Utility class providing helper methods for reading / writing structured data held in a DataStream.
Definition: OgreStreamSerialiser.h:67
Ogre::StreamSerialiser::read
virtual void read(Plane *plane, size_t count=1)
Ogre::StreamSerialiser::ChunkStack
deque< Chunk * >::type ChunkStack
Definition: OgreStreamSerialiser.h:335
Ogre::StreamSerialiser::write
virtual void write(const Matrix4 *m, size_t count=1)
Ogre::StreamSerialiser::writeChunkEnd
virtual void writeChunkEnd(uint32 id)
End writing a chunk.
Ogre::StreamSerialiser::writeDoublesAsFloats
virtual void writeDoublesAsFloats(const double *val, size_t count)
Ogre::StreamSerialiser::Endian
Endian
The endianness of files.
Definition: OgreStreamSerialiser.h:71
Ogre::StreamSerialiser::undoReadChunk
virtual void undoReadChunk(uint32 id)
Call this to 'rewind' the stream to just before the start of the current chunk.
Ogre::uint
unsigned int uint
Definition: OgrePrerequisites.h:114
Ogre::Vector4
4-dimensional homogeneous vector.
Definition: OgreVector4.h:46
Ogre::StreamSerialiser::read
virtual void read(Matrix3 *m, size_t count=1)
Ogre::StreamSerialiser::write
virtual void write(const AxisAlignedBox *aabb, size_t count=1)
Ogre::StreamSerialiser::flipEndian
virtual void flipEndian(void *pData, size_t size, size_t count)
Ogre::StreamSerialiser::determineEndianness
virtual void determineEndianness()
OGRE_DOUBLE_PRECISION
#define OGRE_DOUBLE_PRECISION
If set to 1, Real is typedef'ed to double.
Definition: OgreConfig.h:63
Ogre::Vector2
Standard 2-dimensional vector.
Definition: OgreVector2.h:52
Ogre::StreamSerialiser::writeFloatsAsDoubles
virtual void writeFloatsAsDoubles(const float *val, size_t count)
Ogre::StreamSerialiser::write
virtual void write(const Vector3 *vec, size_t count=1)
Ogre::StreamSerialiser::readDoublesAsFloats
virtual void readDoublesAsFloats(float *val, size_t count)
Ogre::StreamSerialiser::ENDIAN_AUTO
@ ENDIAN_AUTO
Automatically determine endianness.
Definition: OgreStreamSerialiser.h:73
Ogre::StreamSerialiser::Chunk::length
uint32 length
Length of the chunk data in bytes, excluding the header of this chunk (stored)
Definition: OgreStreamSerialiser.h:98
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::StreamSerialiser::Chunk::Chunk
Chunk()
Definition: OgreStreamSerialiser.h:102
Ogre::StreamSerialiser::calculateChecksum
virtual uint32 calculateChecksum(Chunk *c)
Ogre::StreamSerialiser::readChunkBegin
virtual const Chunk * readChunkBegin()
Reads the start of the next chunk in the file.
Ogre::StreamSerialiser::write
virtual void write(const Quaternion *q, size_t count=1)
Ogre::StreamSerialiser::readChunkEnd
virtual void readChunkEnd(uint32 id)
Finish the reading of a chunk.
Ogre::StreamSerialiser::read
virtual void read(String *string)
Ogre::StreamSerialiser::readChunkImpl
virtual Chunk * readChunkImpl()
Ogre::StreamSerialiser::getEndian
virtual Endian getEndian() const
Get the endian mode.
Definition: OgreStreamSerialiser.h:137
Ogre::Node
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:65
Ogre::Ray
Representation of a ray in space, i.e.
Definition: OgreRay.h:47
Ogre::StreamSerialiser::mFlipEndian
bool mFlipEndian
Definition: OgreStreamSerialiser.h:332
Ogre::StreamSerialiser::write
virtual void write(const Matrix3 *m, size_t count=1)
Ogre::StreamSerialiser::readChunkBegin
virtual const Chunk * readChunkBegin(uint32 id, uint16 maxVersion, const String &msg=StringUtil::BLANK)
Reads the start of the next chunk so long as it's of a given ID and version.
Ogre::StreamSerialiser::read
virtual void read(Ray *ray, size_t count=1)
Ogre::StreamSerialiser::write
virtual void write(const Plane *plane, size_t count=1)
Ogre::StreamSerialiser::read
virtual void read(bool *val, size_t count=1)
OgreDataStream.h
Ogre::StreamSerialiser::write
virtual void write(const bool *boolean, size_t count=1)
Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:52
Ogre::StreamSerialiser::REAL_FLOAT
@ REAL_FLOAT
Real is stored as float, reducing precision if you're using OGRE_DOUBLE_PRECISION.
Definition: OgreStreamSerialiser.h:84
Ogre::StreamSerialiser::writeData
virtual void writeData(const void *buf, size_t size, size_t count)
Write arbitrary data to a stream.
Ogre::StreamSerialiser::read
virtual void read(Radian *angle, size_t count=1)

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.