OgreDataStream.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 __DataStream_H__
29 #define __DataStream_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreString.h"
33 #include "OgreSharedPtr.h"
34 #include <istream>
35 #include "OgreHeaderPrefix.h"
36 
37 namespace Ogre {
38 
41  template <size_t cacheSize>
43  {
44  protected:
46  char mBuffer[cacheSize];
47 
49  size_t mValidBytes;
51  size_t mPos;
52 
53  public:
56  {
57  mValidBytes = 0;
58  mPos = 0;
59  }
60 
63  size_t cacheData(const void* buf, size_t count)
64  {
65  assert(avail() == 0 && "It is assumed that you cache data only after you have read everything.");
66 
67  if (count < cacheSize)
68  {
69  // number of bytes written is less than total size of cache
70  if (count + mValidBytes <= cacheSize)
71  {
72  // just append
73  memcpy(mBuffer + mValidBytes, buf, count);
74  mValidBytes += count;
75  }
76  else
77  {
78  size_t begOff = count - (cacheSize - mValidBytes);
79  // override old cache content in the beginning
80  memmove(mBuffer, mBuffer + begOff, mValidBytes - begOff);
81  // append new data
82  memcpy(mBuffer + cacheSize - count, buf, count);
83  mValidBytes = cacheSize;
84  }
85  mPos = mValidBytes;
86  return count;
87  }
88  else
89  {
90  // discard all
91  memcpy(mBuffer, (const char*)buf + count - cacheSize, cacheSize);
92  mValidBytes = mPos = cacheSize;
93  return cacheSize;
94  }
95  }
97  size_t read(void* buf, size_t count)
98  {
99  size_t rb = avail();
100  rb = (rb < count) ? rb : count;
101  memcpy(buf, mBuffer + mPos, rb);
102  mPos += rb;
103  return rb;
104  }
105 
107  bool rewind(size_t count)
108  {
109  if (mPos < count)
110  {
111  clear();
112  return false;
113  }
114  else
115  {
116  mPos -= count;
117  return true;
118  }
119  }
121  bool ff(size_t count)
122  {
123  if (avail() < count)
124  {
125  clear();
126  return false;
127  }
128  else
129  {
130  mPos += count;
131  return true;
132  }
133  }
134 
136  size_t avail() const
137  {
138  return mValidBytes - mPos;
139  }
140 
142  void clear()
143  {
144  mValidBytes = 0;
145  mPos = 0;
146  }
147  };
148 
149 
177  {
178  public:
180  {
181  READ = 1,
182  WRITE = 2
183  };
184  protected:
188  size_t mSize;
191 
192  #define OGRE_STREAM_TEMP_SIZE 128
193  public:
195  DataStream(uint16 accessMode = READ) : mSize(0), mAccess(accessMode) {}
197  DataStream(const String& name, uint16 accessMode = READ)
198  : mName(name), mSize(0), mAccess(accessMode) {}
200  const String& getName(void) { return mName; }
202  uint16 getAccessMode() const { return mAccess; }
204  virtual bool isReadable() const { return (mAccess & READ) != 0; }
206  virtual bool isWriteable() const { return (mAccess & WRITE) != 0; }
207  virtual ~DataStream() {}
208  // Streaming operators
209  template<typename T> DataStream& operator>>(T& val);
216  virtual size_t read(void* buf, size_t count) = 0;
223  virtual size_t write(const void* buf, size_t count)
224  {
225  (void)buf;
226  (void)count;
227  // default to not supported
228  return 0;
229  }
230 
245  virtual size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
246 
261  virtual String getLine( bool trimAfter = true );
262 
268  virtual String getAsString(void);
269 
277  virtual size_t skipLine(const String& delim = "\n");
278 
281  virtual void skip(long count) = 0;
282 
285  virtual void seek( size_t pos ) = 0;
286 
288  virtual size_t tell(void) const = 0;
289 
292  virtual bool eof(void) const = 0;
293 
297  size_t size(void) const { return mSize; }
298 
300  virtual void close(void) = 0;
301 
302 
303  };
304 
309 
314 
318  {
319  protected:
328  public:
329 
340  MemoryDataStream(void* pMem, size_t size, bool freeOnClose = false, bool readOnly = false);
341 
353  MemoryDataStream(const String& name, void* pMem, size_t size,
354  bool freeOnClose = false, bool readOnly = false);
355 
367  MemoryDataStream(DataStream& sourceStream,
368  bool freeOnClose = true, bool readOnly = false);
369 
382  bool freeOnClose = true, bool readOnly = false);
383 
397  MemoryDataStream(const String& name, DataStream& sourceStream,
398  bool freeOnClose = true, bool readOnly = false);
399 
413  MemoryDataStream(const String& name, const DataStreamPtr& sourceStream,
414  bool freeOnClose = true, bool readOnly = false);
415 
422  MemoryDataStream(size_t size, bool freeOnClose = true, bool readOnly = false);
430  MemoryDataStream(const String& name, size_t size,
431  bool freeOnClose = true, bool readOnly = false);
432 
434 
436  uchar* getPtr(void) { return mData; }
437 
439  uchar* getCurrentPtr(void) { return mPos; }
440 
443  size_t read(void* buf, size_t count);
444 
447  size_t write(const void* buf, size_t count);
448 
451  size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
452 
455  size_t skipLine(const String& delim = "\n");
456 
459  void skip(long count);
460 
463  void seek( size_t pos );
464 
467  size_t tell(void) const;
468 
471  bool eof(void) const;
472 
475  void close(void);
476 
478  void setFreeOnClose(bool free) { mFreeOnClose = free; }
479  };
480 
485 
490  {
491  protected:
493  std::istream* mInStream;
495  std::ifstream* mFStreamRO;
497  std::fstream* mFStream;
499 
501  public:
507  FileStreamDataStream(std::ifstream* s,
508  bool freeOnClose = true);
514  FileStreamDataStream(std::fstream* s,
515  bool freeOnClose = true);
516 
524  std::ifstream* s,
525  bool freeOnClose = true);
526 
534  std::fstream* s,
535  bool freeOnClose = true);
536 
552  std::ifstream* s,
553  size_t size,
554  bool freeOnClose = true);
555 
571  std::fstream* s,
572  size_t size,
573  bool freeOnClose = true);
574 
576 
579  size_t read(void* buf, size_t count);
580 
583  size_t write(const void* buf, size_t count);
584 
587  size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
588 
591  void skip(long count);
592 
595  void seek( size_t pos );
596 
599  size_t tell(void) const;
600 
603  bool eof(void) const;
604 
607  void close(void);
608 
609 
610  };
611 
622  {
623  protected:
624  FILE* mFileHandle;
625  public:
627  FileHandleDataStream(FILE* handle, uint16 accessMode = READ);
629  FileHandleDataStream(const String& name, FILE* handle, uint16 accessMode = READ);
631 
634  size_t read(void* buf, size_t count);
635 
638  size_t write(const void* buf, size_t count);
639 
642  void skip(long count);
643 
646  void seek( size_t pos );
647 
650  size_t tell(void) const;
651 
654  bool eof(void) const;
655 
658  void close(void);
659 
660  };
663 }
664 
665 #include "OgreHeaderSuffix.h"
666 
667 #endif
668 
#define _OgreExport
Definition: OgrePlatform.h:257
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
General purpose class used for encapsulating the reading and writing of data.
virtual String getAsString(void)
Returns a String containing the entire stream.
size_t mSize
Size of the data in the stream (may be 0 if size cannot be determined)
virtual size_t tell(void) const =0
Returns the current byte offset from beginning.
virtual size_t skipLine(const String &delim="\n")
Skip a single line from the stream.
String mName
The name (e.g. resource name) that can be used to identify the source for this data (optional)
virtual bool isReadable() const
Reports whether this stream is readable.
DataStream & operator>>(T &val)
uint16 getAccessMode() const
Gets the access mode of the stream.
DataStream(const String &name, uint16 accessMode=READ)
Constructor for creating named streams.
virtual size_t write(const void *buf, size_t count)
Write the requisite number of bytes from the stream (only applicable to streams that are not read-onl...
virtual void skip(long count)=0
Skip a defined number of bytes.
const String & getName(void)
Returns the name of the stream, if it has one.
virtual bool eof(void) const =0
Returns true if the stream has reached the end.
virtual String getLine(bool trimAfter=true)
Returns a String containing the next line of data, optionally trimmed for whitespace.
DataStream(uint16 accessMode=READ)
Constructor for creating unnamed streams.
uint16 mAccess
What type of access is allowed (AccessMode)
virtual ~DataStream()
size_t size(void) const
Returns the total size of the data to be read from the stream, or 0 if this is indeterminate for this...
virtual void close(void)=0
Close the stream; this makes further operations invalid.
virtual void seek(size_t pos)=0
Repositions the read point to a specified byte.
virtual size_t read(void *buf, size_t count)=0
Read the requisite number of bytes from the stream, stopping at the end of the file.
virtual size_t readLine(char *buf, size_t maxCount, const String &delim="\n")
Get a single line from the stream.
virtual bool isWriteable() const
Reports whether this stream is writeable.
Common subclass of DataStream for handling data from C-style file handles.
FileHandleDataStream(const String &name, FILE *handle, uint16 accessMode=READ)
Create named stream from a C file handle.
void skip(long count)
Skip a defined number of bytes.
bool eof(void) const
Returns true if the stream has reached the end.
size_t tell(void) const
Returns the current byte offset from beginning.
void close(void)
Close the stream; this makes further operations invalid.
size_t write(const void *buf, size_t count)
Write the requisite number of bytes from the stream (only applicable to streams that are not read-onl...
FileHandleDataStream(FILE *handle, uint16 accessMode=READ)
Create stream from a C file handle.
void seek(size_t pos)
Repositions the read point to a specified byte.
size_t read(void *buf, size_t count)
Read the requisite number of bytes from the stream, stopping at the end of the file.
Common subclass of DataStream for handling data from std::basic_istream.
FileStreamDataStream(std::fstream *s, bool freeOnClose=true)
Construct a read-write stream from an STL stream.
bool eof(void) const
Returns true if the stream has reached the end.
FileStreamDataStream(const String &name, std::ifstream *s, bool freeOnClose=true)
Construct named read-only stream from an STL stream.
void skip(long count)
Skip a defined number of bytes.
FileStreamDataStream(std::ifstream *s, bool freeOnClose=true)
Construct a read-only stream from an STL stream.
std::fstream * mFStream
Reference to source file stream (read-write)
size_t write(const void *buf, size_t count)
Write the requisite number of bytes from the stream (only applicable to streams that are not read-onl...
FileStreamDataStream(const String &name, std::ifstream *s, size_t size, bool freeOnClose=true)
Construct named read-only stream from an STL stream, and tell it the size.
std::istream * mInStream
Reference to source stream (read)
size_t read(void *buf, size_t count)
Read the requisite number of bytes from the stream, stopping at the end of the file.
size_t tell(void) const
Returns the current byte offset from beginning.
FileStreamDataStream(const String &name, std::fstream *s, size_t size, bool freeOnClose=true)
Construct named read-write stream from an STL stream, and tell it the size.
FileStreamDataStream(const String &name, std::fstream *s, bool freeOnClose=true)
Construct named read-write stream from an STL stream.
size_t readLine(char *buf, size_t maxCount, const String &delim="\n")
Get a single line from the stream.
void close(void)
Close the stream; this makes further operations invalid.
std::ifstream * mFStreamRO
Reference to source file stream (read-only)
void seek(size_t pos)
Repositions the read point to a specified byte.
Common subclass of DataStream for handling data from chunks of memory.
uchar * mData
Pointer to the start of the data area.
bool mFreeOnClose
Do we delete the memory on close.
void seek(size_t pos)
Repositions the read point to a specified byte.
size_t readLine(char *buf, size_t maxCount, const String &delim="\n")
Get a single line from the stream.
void close(void)
Close the stream; this makes further operations invalid.
MemoryDataStream(const String &name, void *pMem, size_t size, bool freeOnClose=false, bool readOnly=false)
Wrap an existing memory chunk in a named stream.
uchar * mEnd
Pointer to the end of the memory.
MemoryDataStream(DataStream &sourceStream, bool freeOnClose=true, bool readOnly=false)
Create a stream which pre-buffers the contents of another stream.
size_t skipLine(const String &delim="\n")
Skip a single line from the stream.
MemoryDataStream(const String &name, DataStream &sourceStream, bool freeOnClose=true, bool readOnly=false)
Create a named stream which pre-buffers the contents of another stream.
MemoryDataStream(void *pMem, size_t size, bool freeOnClose=false, bool readOnly=false)
Wrap an existing memory chunk in a stream.
uchar * getPtr(void)
Get a pointer to the start of the memory block this stream holds.
MemoryDataStream(const String &name, size_t size, bool freeOnClose=true, bool readOnly=false)
Create a named stream with a brand new empty memory chunk.
size_t read(void *buf, size_t count)
Read the requisite number of bytes from the stream, stopping at the end of the file.
void skip(long count)
Skip a defined number of bytes.
MemoryDataStream(DataStreamPtr &sourceStream, bool freeOnClose=true, bool readOnly=false)
Create a stream which pre-buffers the contents of another stream.
MemoryDataStream(const String &name, const DataStreamPtr &sourceStream, bool freeOnClose=true, bool readOnly=false)
Create a named stream which pre-buffers the contents of another stream.
uchar * getCurrentPtr(void)
Get a pointer to the current position in the memory block this stream holds.
size_t write(const void *buf, size_t count)
Write the requisite number of bytes from the stream (only applicable to streams that are not read-onl...
void setFreeOnClose(bool free)
Sets whether or not to free the encapsulated memory on close.
uchar * mPos
Pointer to the current position in the memory.
size_t tell(void) const
Returns the current byte offset from beginning.
bool eof(void) const
Returns true if the stream has reached the end.
MemoryDataStream(size_t size, bool freeOnClose=true, bool readOnly=false)
Create a stream with a brand new empty memory chunk.
Template version of cache based on static array.
bool ff(size_t count)
Step forward in cached stream by 'count' bytes.
size_t mPos
Current read position.
char mBuffer[cacheSize]
Static buffer.
bool rewind(size_t count)
Step back in cached stream by 'count' bytes.
StaticCache()
Constructor.
size_t cacheData(const void *buf, size_t count)
Cache data pointed by 'buf'.
size_t read(void *buf, size_t count)
Read data from cache to 'buf' (maximum 'count' bytes).
void clear()
Clear the cache.
size_t mValidBytes
Number of bytes valid in cache (written from the beginning of static buffer)
size_t avail() const
Returns number of bytes available for reading in cache after rewinding.
SharedPtr< DataStream > DataStreamPtr
Shared pointer to allow data streams to be passed around without worrying about deallocation.
SharedPtr< DataStreamList > DataStreamListPtr
Shared pointer to list of DataStream items.
list< DataStreamPtr >::type DataStreamList
List of DataStream items.
SharedPtr< MemoryDataStream > MemoryDataStreamPtr
Shared pointer to allow memory data streams to be passed around without worrying about deallocation.
unsigned char uchar
In order to avoid finger-aches :)
unsigned short uint16
Definition: OgrePlatform.h:360
_StringBase String
std::list< T, A > type

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