CPGFMemoryStream Class Reference

Memory stream class. More...

#include <PGFstream.h>

Inheritance diagram for CPGFMemoryStream:
CPGFStream

List of all members.

Public Member Functions

 CPGFMemoryStream (size_t size) THROW_
 CPGFMemoryStream (UINT8 *pBuffer, size_t size) THROW_
void Reinitialize (UINT8 *pBuffer, size_t size) THROW_
virtual ~CPGFMemoryStream ()
virtual void Write (int *count, void *buffer) THROW_
virtual void Read (int *count, void *buffer)
virtual void SetPos (short posMode, INT64 posOff) THROW_
virtual UINT64 GetPos () const
virtual bool IsValid () const
size_t GetSize () const
const UINT8 * GetBuffer () const
UINT8 * GetBuffer ()
UINT64 GetEOS () const
void SetEOS (UINT64 length)

Protected Attributes

UINT8 * m_buffer
UINT8 * m_pos
 buffer start address and current buffer address
UINT8 * m_eos
 end of stream (first address beyond written area)
size_t m_size
 buffer size
bool m_allocated
 indicates a new allocated buffer

Detailed Description

Memory stream class.

A PGF stream subclass for internal memory.

Author:
C. Stamm

Definition at line 106 of file PGFstream.h.


Constructor & Destructor Documentation

CPGFMemoryStream::CPGFMemoryStream ( size_t  size  ) 

Constructor

Parameters:
size Size of new allocated memory buffer

Allocate memory block of given size

Parameters:
size Memory size

Definition at line 78 of file PGFstream.cpp.

00079 : m_size(size)
00080 , m_allocated(true) {
00081         m_buffer = m_pos = m_eos = new(std::nothrow) UINT8[m_size];
00082         if (!m_buffer) ReturnWithError(InsufficientMemory);
00083 }

CPGFMemoryStream::CPGFMemoryStream ( UINT8 *  pBuffer,
size_t  size 
)

Constructor. Use already allocated memory of given size

Parameters:
pBuffer Memory location
size Memory size

Use already allocated memory of given size

Parameters:
pBuffer Memory location
size Memory size

Definition at line 89 of file PGFstream.cpp.

00090 : m_buffer(pBuffer)
00091 , m_pos(pBuffer)
00092 , m_eos(pBuffer + size)
00093 , m_size(size)
00094 , m_allocated(false) {
00095         ASSERT(IsValid());
00096 }

virtual CPGFMemoryStream::~CPGFMemoryStream (  )  [inline, virtual]

Definition at line 128 of file PGFstream.h.

00128                                     { 
00129                 m_pos = 0; 
00130                 if (m_allocated) {
00131                         // the memory buffer has been allocated inside of CPMFmemoryStream constructor
00132                         delete[] m_buffer; m_buffer = 0;
00133                 }
00134         }


Member Function Documentation

UINT8* CPGFMemoryStream::GetBuffer (  )  [inline]
Returns:
Memory buffer

Definition at line 147 of file PGFstream.h.

00147 { return m_buffer; }

const UINT8* CPGFMemoryStream::GetBuffer (  )  const [inline]
Returns:
Memory buffer

Definition at line 145 of file PGFstream.h.

00145 { return m_buffer; }

UINT64 CPGFMemoryStream::GetEOS (  )  const [inline]
Returns:
relative position of end of stream (= stream length)

Definition at line 149 of file PGFstream.h.

00149 { ASSERT(IsValid()); return m_eos - m_buffer; }

virtual UINT64 CPGFMemoryStream::GetPos (  )  const [inline, virtual]

Get current stream position.

Returns:
Current stream position

Implements CPGFStream.

Definition at line 139 of file PGFstream.h.

00139 { ASSERT(IsValid()); return m_pos - m_buffer; }

size_t CPGFMemoryStream::GetSize (  )  const [inline]
Returns:
Memory size

Definition at line 143 of file PGFstream.h.

00143 { return m_size; }

virtual bool CPGFMemoryStream::IsValid (  )  const [inline, virtual]

Check stream validity.

Returns:
True if stream and current position is valid

Implements CPGFStream.

Definition at line 140 of file PGFstream.h.

00140 { return m_buffer != 0; }

void CPGFMemoryStream::Read ( int *  count,
void *  buffer 
) [virtual]

Read some bytes from this stream and stores them into a buffer.

Parameters:
count A pointer to a value containing the number of bytes should be read. After this call it contains the number of read bytes.
buffer A memory buffer

Implements CPGFStream.

Definition at line 148 of file PGFstream.cpp.

00148                                                      {
00149         ASSERT(IsValid());
00150         ASSERT(count);
00151         ASSERT(buffPtr);
00152         ASSERT(m_buffer + m_size >= m_eos);
00153         ASSERT(m_pos <= m_eos);
00154         
00155         if (m_pos + *count <= m_eos) {
00156                 memcpy(buffPtr, m_pos, *count);
00157                 m_pos += *count;
00158         } else {
00159                 // end of memory block reached -> read only until end
00160                 *count = (int)__max(0, m_eos - m_pos);
00161                 memcpy(buffPtr, m_pos, *count);
00162                 m_pos += *count;
00163         }
00164         ASSERT(m_pos <= m_eos);
00165 }

void CPGFMemoryStream::Reinitialize ( UINT8 *  pBuffer,
size_t  size 
)

Use already allocated memory of given size

Parameters:
pBuffer Memory location
size Memory size

Definition at line 102 of file PGFstream.cpp.

00102                                                                       {
00103         if (!m_allocated) {
00104                 m_buffer = m_pos = pBuffer;
00105                 m_size = size;
00106                 m_eos = m_buffer + size;
00107         }
00108 }

void CPGFMemoryStream::SetEOS ( UINT64  length  )  [inline]
Parameters:
length Stream length (= relative position of end of stream)

Definition at line 151 of file PGFstream.h.

00151 { ASSERT(IsValid()); m_eos = m_buffer + length; }

void CPGFMemoryStream::SetPos ( short  posMode,
INT64  posOff 
) [virtual]

Set stream position either absolute or relative.

Parameters:
posMode A position mode (FSFromStart, FSFromCurrent, FSFromEnd)
posOff A new stream position (absolute positioning) or a position offset (relative positioning)

Implements CPGFStream.

Definition at line 168 of file PGFstream.cpp.

00168                                                                 {
00169         ASSERT(IsValid());
00170         switch(posMode) {
00171         case FSFromStart:
00172                 m_pos = m_buffer + posOff;
00173                 break;
00174         case FSFromCurrent:
00175                 m_pos += posOff;
00176                 break;
00177         case FSFromEnd:
00178                 m_pos = m_eos + posOff;
00179                 break;
00180         default:
00181                 ASSERT(false);
00182         }
00183         if (m_pos > m_eos) 
00184                 ReturnWithError(InvalidStreamPos);
00185 }

void CPGFMemoryStream::Write ( int *  count,
void *  buffer 
) [virtual]

Write some bytes out of a buffer into this stream.

Parameters:
count A pointer to a value containing the number of bytes should be written. After this call it contains the number of written bytes.
buffer A memory buffer

Implements CPGFStream.

Definition at line 111 of file PGFstream.cpp.

00111                                                              {
00112         ASSERT(count);
00113         ASSERT(buffPtr);
00114         ASSERT(IsValid());
00115         const size_t deltaSize = 0x4000 + *count;
00116         
00117         if (m_pos + *count <= m_buffer + m_size) {
00118                 memcpy(m_pos, buffPtr, *count);
00119                 m_pos += *count; 
00120                 if (m_pos > m_eos) m_eos = m_pos;
00121         } else if (m_allocated) {
00122                 // memory block is too small -> reallocate a deltaSize larger block
00123                 size_t offset = m_pos - m_buffer;
00124                 UINT8 *buf_tmp = (UINT8 *)realloc(m_buffer, m_size + deltaSize);
00125                 if (!buf_tmp) {
00126                         delete[] m_buffer;
00127                         m_buffer = 0;
00128                         ReturnWithError(InsufficientMemory);
00129                 } else {
00130                         m_buffer = buf_tmp;
00131                 }
00132                 m_size += deltaSize;
00133 
00134                 // reposition m_pos
00135                 m_pos = m_buffer + offset;
00136 
00137                 // write block
00138                 memcpy(m_pos, buffPtr, *count);
00139                 m_pos += *count; 
00140                 if (m_pos > m_eos) m_eos = m_pos;
00141         } else {
00142                 ReturnWithError(InsufficientMemory);    
00143         }
00144         ASSERT(m_pos <= m_eos);
00145 }


Member Data Documentation

indicates a new allocated buffer

Definition at line 111 of file PGFstream.h.

UINT8* CPGFMemoryStream::m_buffer [protected]

Definition at line 108 of file PGFstream.h.

UINT8* CPGFMemoryStream::m_eos [protected]

end of stream (first address beyond written area)

Definition at line 109 of file PGFstream.h.

UINT8 * CPGFMemoryStream::m_pos [protected]

buffer start address and current buffer address

Definition at line 108 of file PGFstream.h.

size_t CPGFMemoryStream::m_size [protected]

buffer size

Definition at line 110 of file PGFstream.h.


The documentation for this class was generated from the following files:

Generated on 18 Feb 2019 for libpgf by  doxygen 1.6.1