#include "comBuf.h"

Inheritance diagram for comBuf:

Collaboration diagram for comBuf:

Classes
class	insufficentBytesAvailable

struct	popStatus

Public Member Functions
	comBuf ()

unsigned	unoccupiedBytes () const

unsigned	occupiedBytes () const

unsigned	uncommittedBytes () const

void	clear ()

unsigned	copyInBytes (const void *pBuf, unsigned nBytes)

unsigned	push (comBuf &)

template<class T >
bool	push (const T &value)

template<class T >
unsigned	push (const T *pValue, unsigned nElem)

unsigned	push (const epicsInt8 *pValue, unsigned nElem)

unsigned	push (const epicsUInt8 *pValue, unsigned nElem)

unsigned	push (const epicsOldString *pValue, unsigned nElem)

void	commitIncomming ()

void	clearUncommittedIncomming ()

bool	copyInAllBytes (const void *pBuf, unsigned nBytes)

unsigned	copyOutBytes (void *pBuf, unsigned nBytes)

bool	copyOutAllBytes (void *pBuf, unsigned nBytes)

unsigned	removeBytes (unsigned nBytes)

bool	flushToWire (wireSendAdapter &, const epicsTime &currentTime)

void	fillFromWire (wireRecvAdapter &, statusWireIO &)

template<class T >
popStatus	pop (T &)

void *	operator new (size_t size, comBufMemoryManager &)

void	operator delete (void *)

template<class T >
bool	push (const T *)

Public Member Functions inherited from tsDLNode< comBuf >
	tsDLNode ()

	tsDLNode (const tsDLNode< comBuf > &)

const tsDLNode< comBuf > &	operator= (const tsDLNode< comBuf > &)

Static Public Member Functions
static unsigned	capacityBytes ()

static void	throwInsufficentBytesException ()

Public Attributes
epicsPlacementDeleteOperator((void *, comBufMemoryManager &)) private unsigne	nextWriteIndex )

unsigned	nextReadIndex

epicsUInt8	buf [comBufSize]

Detailed Description

Definition at line 75 of file comBuf.h.

Constructor & Destructor Documentation

comBuf::comBuf ( )

inline

Definition at line 135 of file comBuf.h.

                        : commitIndex ( 0u ),
     nextWriteIndex ( 0u ), nextReadIndex ( 0u )
 {
 }

Member Function Documentation

unsigned comBuf::capacityBytes ( )

inlinestatic

Definition at line 171 of file comBuf.h.

 {
     return comBufSize;
 }

void comBuf::clear ( )

inline

Definition at line 140 of file comBuf.h.

 {
     this->commitIndex = 0u;
     this->nextWriteIndex = 0u;
     this->nextReadIndex = 0u;
 }

void comBuf::clearUncommittedIncomming ( )

inline

Definition at line 247 of file comBuf.h.

 {
     this->nextWriteIndex = this->commitIndex;
 }

void comBuf::commitIncomming ( )

inline

Definition at line 242 of file comBuf.h.

 {
     this->commitIndex = this->nextWriteIndex;
 }

bool comBuf::copyInAllBytes	(	const void *	pBuf,
		unsigned	nBytes
	)

inline

Definition at line 252 of file comBuf.h.

 {
     unsigned index = this->nextWriteIndex;
     unsigned available = sizeof ( this->buf ) - index;
     if ( nBytes <= available ) {
         memcpy ( & this->buf[index], pBuf, nBytes );
         this->nextWriteIndex = index + nBytes;
         return true;
     }
     return false;
 }

unsigned comBuf::copyInBytes	(	const void *	pBuf,
		unsigned	nBytes
	)

inline

Definition at line 264 of file comBuf.h.

 {
     unsigned index = this->nextWriteIndex;
     unsigned available = sizeof ( this->buf ) - index;
     if ( nBytes > available ) {
         nBytes = available;
     }
     memcpy ( & this->buf[index], pBuf, nBytes );
     this->nextWriteIndex = index + nBytes;
     return nBytes;
 }

bool comBuf::copyOutAllBytes	(	void *	pBuf,
		unsigned	nBytes
	)

inline

Definition at line 276 of file comBuf.h.

 {
     unsigned index = this->nextReadIndex;
     unsigned occupied = this->commitIndex - index;
     if ( nBytes <= occupied ) {
         memcpy ( pBuf, &this->buf[index], nBytes);
         this->nextReadIndex = index + nBytes;
         return true;
     }
     return false;
 }

unsigned comBuf::copyOutBytes	(	void *	pBuf,
		unsigned	nBytes
	)

inline

Definition at line 288 of file comBuf.h.

 {
     unsigned index = this->nextReadIndex;
     unsigned occupied = this->commitIndex - index;
     if ( nBytes > occupied ) {
         nBytes = occupied;
     }
     memcpy ( pBuf, &this->buf[index], nBytes);
     this->nextReadIndex = index + nBytes;
     return nBytes;
 }

void comBuf::fillFromWire	(	wireRecvAdapter &	wire,
		statusWireIO &	stat
	)

inline

Definition at line 176 of file comBuf.h.

 {
     wire.recvBytes (
         & this->buf[this->nextWriteIndex],
         sizeof ( this->buf ) - this->nextWriteIndex, stat );
     if ( stat.circuitState == swioConnected ) {
         this->nextWriteIndex += stat.bytesCopied;
     }
 }

bool comBuf::flushToWire	(	wireSendAdapter &	wire,
		const epicsTime &	currentTime
	)

Definition at line 30 of file comBuf.cpp.

 {
     unsigned index = this->nextReadIndex;
     unsigned finalIndex = this->commitIndex;
     while ( index < finalIndex ) {
         unsigned nBytes = wire.sendBytes (
             &this->buf[index], finalIndex - index, currentTime );
         if ( nBytes == 0u ) {
             this->nextReadIndex = index;
             return false;
         }
         index += nBytes;
     }
     this->nextReadIndex = index;
     return true;
 }

unsigned comBuf::occupiedBytes ( ) const

inline

Definition at line 152 of file comBuf.h.

 {
     return this->commitIndex - this->nextReadIndex;
 }

void comBuf::operator delete ( void * )

Definition at line 54 of file comBuf.cpp.

 {
     // Visual C++ .net appears to require operator delete if
     // placement operator delete is defined? I smell a ms rat
     // because if I declare placement new and delete, but
     // comment out the placement delete definition there are
     // no undefined symbols.
     errlogPrintf ( "%s:%d this compiler is confused about placement delete - memory was probably leaked",
         __FILE__, __LINE__ );
 }

void * comBuf::operator new	(	size_t	size,
		comBufMemoryManager &	mgr
	)

inline

Definition at line 121 of file comBuf.h.

 {
     return mgr.allocate ( size );
 }

template<class T >

comBuf::popStatus comBuf::pop ( T & returnVal )

Definition at line 312 of file comBuf.h.

 {
     unsigned nrIndex = this->nextReadIndex;
     unsigned popIndex = nrIndex + sizeof ( returnVal );
     unsigned cIndex = this->commitIndex;
     popStatus status;
     status.success = true;
     status.nowEmpty = false;
     if ( popIndex >= cIndex ) {
         if ( popIndex == cIndex ) {
             status.nowEmpty = true;
         }
         else {
             status.success = false;
             return status;
         }
     }
     WireGet ( & this->buf[ nrIndex ], returnVal );
     this->nextReadIndex = popIndex;
     return status;
 }

unsigned comBuf::push ( comBuf & bufIn )

inline

Definition at line 162 of file comBuf.h.

 {
     unsigned nBytes = this->copyInBytes (
         & bufIn.buf[ bufIn.nextReadIndex ],
         bufIn.commitIndex - bufIn.nextReadIndex );
     bufIn.nextReadIndex += nBytes;
     return nBytes;
 }

template<class T >

bool comBuf::push ( const T & value )

inline

Definition at line 188 of file comBuf.h.

 {
     unsigned index = this->nextWriteIndex;
     unsigned available = sizeof ( this->buf ) - index;
     if ( sizeof ( value ) > available ) {
         return false;
     }
     WireSet ( value, & this->buf[index] );
     this->nextWriteIndex = index + sizeof ( value );
     return true;
 }

template<class T >

unsigned comBuf::push	(	const T *	pValue,
		unsigned	nElem
	)

Definition at line 225 of file comBuf.h.

 {
     unsigned index = this->nextWriteIndex;
     unsigned available = sizeof ( this->buf ) - index;
     unsigned nBytes = sizeof ( *pValue ) * nElem;
     if ( nBytes > available ) {
         nElem = available / sizeof ( *pValue );
     }
     for ( unsigned i = 0u; i < nElem; i++ ) {
         // allow native floating point formats to be converted to IEEE
         WireSet( pValue[i], &this->buf[index] );
         index += sizeof ( *pValue );
     }
     this->nextWriteIndex = index;
     return nElem;
 }

unsigned comBuf::push	(	const epicsInt8 *	pValue,
		unsigned	nElem
	)

inline

Definition at line 200 of file comBuf.h.

 {
     return copyInBytes ( pValue, nElem );
 }

unsigned comBuf::push	(	const epicsUInt8 *	pValue,
		unsigned	nElem
	)

inline

Definition at line 205 of file comBuf.h.

 {
     return copyInBytes ( pValue, nElem );
 }

unsigned comBuf::push	(	const epicsOldString *	pValue,
		unsigned	nElem
	)

inline

Definition at line 210 of file comBuf.h.

 {
     unsigned index = this->nextWriteIndex;
     unsigned available = sizeof ( this->buf ) - index;
     unsigned nBytes = sizeof ( *pValue ) * nElem;
     if ( nBytes > available ) {
         nElem = available / sizeof ( *pValue );
         nBytes = nElem * sizeof ( *pValue );
     }
     memcpy ( &this->buf[ index ], pValue, nBytes );
     this->nextWriteIndex = index + nBytes;
     return nElem;
 }

template<class T >

bool comBuf::push ( const T * )

unsigned comBuf::removeBytes ( unsigned nBytes )

inline

Definition at line 300 of file comBuf.h.

 {
     unsigned index = this->nextReadIndex;
     unsigned occupied = this->commitIndex - index;
     if ( nBytes > occupied ) {
         nBytes = occupied;
     }
     this->nextReadIndex = index + nBytes;
     return nBytes;
 }

void comBuf::throwInsufficentBytesException ( )

static

Definition at line 49 of file comBuf.cpp.

 {
     throw comBuf::insufficentBytesAvailable ();
 }

unsigned comBuf::uncommittedBytes ( ) const

inline

Definition at line 157 of file comBuf.h.

 {
     return this->nextWriteIndex - this->commitIndex;
 }

unsigned comBuf::unoccupiedBytes ( ) const

inline

Definition at line 147 of file comBuf.h.

 {
     return sizeof ( this->buf ) - this->nextWriteIndex;
 }

Member Data Documentation

epicsUInt8 comBuf::buf[comBufSize]

Definition at line 115 of file comBuf.h.

unsigned comBuf::nextReadIndex

Definition at line 114 of file comBuf.h.

epicsPlacementDeleteOperator (( void *, comBufMemoryManager & )) private unsigne comBuf::nextWriteIndex)

Definition at line 110 of file comBuf.h.

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

modules/ca/src/client/comBuf.h
modules/ca/src/client/comBuf.cpp

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation