df_LimitedStream Class Reference
[G_new_group]

#include <df_LimitedStream.h>

Collaboration diagram for df_LimitedStream:

Detailed Description

Definition at line 36 of file df_LimitedStream.h.


Public Member Functions
	df_LimitedStream (int a_recordSize)
	~df_LimitedStream (void)
int	Write (const char *a_buff_p, int a_size)
bool	Write (string &a_limStream)
	limStream will be replaced with current return true if limStream is full length
int	Read (char *a_buff_p, int a_size)
	read the a_size of data from limited stream.
void	SetNextLimStream (df_LimitedStream *a_nextLimStream_p)
df_LimitedStream *	GetNextLimStream ()
string &	GetLimStreamBufRef ()
void	ReadReset ()
void	Cut (UInt32_t a_cutSize)
void	Clear ()
Public Attributes
	log_CLASSID_m
Private Attributes
unsigned int	m_recSize
unsigned int	m_maxStreamSize
	stream size is limited by vector size and record size.
string	m_limStream
UInt32_t	m_readPos
	current read position
df_LimitedStream *	m_nextLimStream_p
Friends
class	ut_fio_LimitedStream

Constructor & Destructor Documentation

df_LimitedStream::df_LimitedStream ( int a_recordSize ) [inline]

Definition at line 39 of file df_LimitedStream.h.

00040     :
00041     m_recSize(a_recordSize),
00042     m_maxStreamSize(ivd_MAX_STREAM_SIZE(a_recordSize)),
00043     m_readPos (0),
00044     m_nextLimStream_p(NULL)
00045     { };

df_LimitedStream::~df_LimitedStream ( void ) [inline]

Definition at line 47 of file df_LimitedStream.h.

References m_nextLimStream_p, and NULL.

00047                             {
00048         if (m_nextLimStream_p != NULL) {
00049             delete m_nextLimStream_p;
00050         }
00051     };

Member Function Documentation

int df_LimitedStream::Write	(	const char *	a_buff_p,
		int	a_size
	)

Definition at line 35 of file df_LimitedStream.cpp.

References dbg_DETAIL, log_DBG_m, log_FUNC_m, m_limStream, and m_maxStreamSize.

Referenced by df_Stream::Write(), Write(), and df_Stream::WriteZeroes().

00035                                                             {
00036     log_FUNC_m(Write);
00037     log_DBG_m(dbg_DETAIL, " limStream string size " << m_limStream.size()
00038                         << " adding data size = " <<  a_size);
00039     if (m_limStream.size() + a_size > m_maxStreamSize) {
00040         int written = m_maxStreamSize - m_limStream.size();
00041         m_limStream.append(a_buff_p, written);
00042         return written;
00043     }
00044     else {
00045         m_limStream.append(a_buff_p, a_size);
00046         return a_size;
00047     }
00048 }

Here is the caller graph for this function:

bool df_LimitedStream::Write ( string & a_limStream ) [inline]

limStream will be replaced with current return true if limStream is full length

Definition at line 58 of file df_LimitedStream.h.

References m_limStream, m_maxStreamSize, and Write().

00058                                     {
00059         if (m_limStream.size() == 0) {
00060             a_limStream.swap(m_limStream);
00061         }
00062         else {
00063             Write(a_limStream.data(), a_limStream.size());
00064         }
00065         return (m_limStream.size() == m_maxStreamSize);
00066     };

Here is the call graph for this function:

int df_LimitedStream::Read	(	char *	a_buff_p,
		int	a_size
	)

read the a_size of data from limited stream.

Return size of data read from this stream. If it's less than a_size then missing data is read from next limitedStream.

Definition at line 52 of file df_LimitedStream.cpp.

References dbg_DETAIL, log_DBG_m, log_FUNC_m, m_limStream, and m_readPos.

Referenced by df_Stream::Read().

00052                                                       {   
00053     log_FUNC_m(Read);    
00054     log_DBG_m(dbg_DETAIL, " get data from limited stream. sized " << a_size
00055                        << " readPos " << m_readPos
00056                        << " m_limStream.size() " << m_limStream.size() );
00057     if (m_readPos + a_size > m_limStream.size()) {
00058         int read = m_limStream.size() - m_readPos;
00059         memcpy(a_buff_p, m_limStream.data() + m_readPos, read);
00060         m_readPos += read;
00061         return read;
00062     }
00063     else {
00064         memcpy(a_buff_p, m_limStream.data() + m_readPos, a_size);
00065         m_readPos += a_size;
00066         return a_size;
00067     }
00068 }

Here is the caller graph for this function:

void df_LimitedStream::SetNextLimStream ( df_LimitedStream * a_nextLimStream_p ) [inline]

Definition at line 74 of file df_LimitedStream.h.

References m_nextLimStream_p.

Referenced by df_Stream::Write().

00074                                                                  {
00075         m_nextLimStream_p = a_nextLimStream_p;
00076     }

Here is the caller graph for this function:

df_LimitedStream* df_LimitedStream::GetNextLimStream ( ) [inline]

Definition at line 78 of file df_LimitedStream.h.

References m_nextLimStream_p.

Referenced by df_Stream::Read(), and fsc_nsStream::Write2DB().

00078                                          {
00079         return m_nextLimStream_p;
00080     }

Here is the caller graph for this function:

string& df_LimitedStream::GetLimStreamBufRef ( ) [inline]

Definition at line 82 of file df_LimitedStream.h.

References m_limStream.

Referenced by fsc_nsAttrStream::Dump(), and fsc_nsStream::Write2DB().

00082 { return m_limStream;};

Here is the caller graph for this function:

void df_LimitedStream::ReadReset ( ) [inline]

Definition at line 84 of file df_LimitedStream.h.

References m_nextLimStream_p, m_readPos, and ReadReset().

Referenced by ReadReset().

00084                      {
00085         m_readPos = 0;
00086         if (m_nextLimStream_p) {
00087             m_nextLimStream_p->ReadReset();
00088         }
00089     };

Here is the call graph for this function:

Here is the caller graph for this function:

void df_LimitedStream::Cut ( UInt32_t a_cutSize )

Definition at line 72 of file df_LimitedStream.cpp.

References dbg_DETAIL, log_DBG_m, log_FUNC_m, m_limStream, m_nextLimStream_p, and NULL.

Referenced by df_Stream::Cut().

00072                                              {
00073     log_FUNC_m(Cut);    
00074     m_limStream.resize(a_cutSize);
00075     log_DBG_m(dbg_DETAIL, "Cut size " << a_cutSize
00076                           << " m_limStream.size() after Cut " << m_limStream.size() );
00077     if (m_nextLimStream_p) {
00078         delete m_nextLimStream_p;
00079         m_nextLimStream_p = NULL;
00080     }
00081 }

Here is the caller graph for this function:

void df_LimitedStream::Clear ( void ) [inline]

Definition at line 93 of file df_LimitedStream.h.

References m_limStream, m_nextLimStream_p, and NULL.

00093                  {
00094         if (m_nextLimStream_p) {
00095             delete m_nextLimStream_p;
00096             m_nextLimStream_p = NULL;
00097         }
00098         m_limStream.clear();
00099     };

Friends And Related Function Documentation

friend class ut_fio_LimitedStream [friend]

Definition at line 37 of file df_LimitedStream.h.

Member Data Documentation

df_LimitedStream::log_CLASSID_m

Definition at line 99 of file df_LimitedStream.h.

unsigned int df_LimitedStream::m_recSize [private]

Definition at line 103 of file df_LimitedStream.h.

unsigned int df_LimitedStream::m_maxStreamSize [private]

stream size is limited by vector size and record size.

vector can contain 256 records. Thus max limited stream size is 256 * record size. NOTE: not all buffer is used for data. The last few bytes are reserved for next vector size and its index in DB.

Definition at line 110 of file df_LimitedStream.h.

Referenced by Write().

string df_LimitedStream::m_limStream [private]

Definition at line 111 of file df_LimitedStream.h.

Referenced by Clear(), Cut(), GetLimStreamBufRef(), Read(), and Write().