OGRE  1.9.0
OgreDataStream.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE 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
37namespace Ogre {
38
41 template <size_t cacheSize>
43 {
44 protected:
46 char mBuffer[cacheSize];
47
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 }
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 }
96
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 }
120
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
156
177 {
178 public:
180 {
181 READ = 1,
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) {}
199
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
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:
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 };
661
663}
664
665#include "OgreHeaderSuffix.h"
666
667#endif
668
#define _OgreExport
virtual String getAsString(void)
Returns a String containing the entire stream.
DataStream & operator>>(T &val)
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.
uint16 getAccessMode() const
Gets the access mode of the stream.
const String & getName(void)
Returns the name of the stream, if it has one.
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.
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)
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.
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.
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.
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.
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.
uchar * getCurrentPtr(void)
Get a pointer to the current position in the memory block this stream holds.
Reference-counted shared pointer, used for objects where implicit destruction is required.
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
GeneralAllocatedObject StreamAlloc
_StringBase String
std::list< T, A > type