epics::pvData::ByteBuffer Class Reference

This class implements a Bytebuffer that is like the java.nio.ByteBuffer. More...

#include "byteBuffer.h"

Public Member Functions
	ByteBuffer (std::size_t size, int byteOrder=EPICS_BYTE_ORDER)
	ByteBuffer (char *buffer, std::size_t size, int byteOrder=EPICS_BYTE_ORDER)
	~ByteBuffer ()
void	setEndianess (int byteOrder)
const char *	getBuffer () const
void	clear ()
void	flip ()
void	rewind ()
std::size_t	getPosition () const
void	setPosition (std::size_t pos)
std::size_t	getLimit () const
void	setLimit (std::size_t limit)
std::size_t	getRemaining () const
EPICS_ALWAYS_INLINE std::size_t	getSize () const
template<typename T >
void	put (T value)
template<typename T >
void	put (std::size_t index, T value) const
template<typename T >
T	get ()
template<typename T >
T	get (std::size_t index) const
void	put (const char *src, std::size_t src_offset, std::size_t count)
void	get (char *dest, std::size_t dest_offset, std::size_t count)
template<typename T >
void	putArray (const T *values, std::size_t count)
template<typename T >
void	getArray (T *values, std::size_t count)
template<typename T >
EPICS_ALWAYS_INLINE bool	reverse () const
void	align (std::size_t size, char fill='\0')
EPICS_ALWAYS_INLINE void	putBoolean (bool value)
EPICS_ALWAYS_INLINE void	putByte (int8 value)
EPICS_ALWAYS_INLINE void	putShort (int16 value)
EPICS_ALWAYS_INLINE void	putInt (int32 value)
EPICS_ALWAYS_INLINE void	putLong (int64 value)
EPICS_ALWAYS_INLINE void	putFloat (float value)
EPICS_ALWAYS_INLINE void	putDouble (double value)
EPICS_ALWAYS_INLINE void	putBoolean (std::size_t index, bool value)
EPICS_ALWAYS_INLINE void	putByte (std::size_t index, int8 value)
EPICS_ALWAYS_INLINE void	putShort (std::size_t index, int16 value)
EPICS_ALWAYS_INLINE void	putInt (std::size_t index, int32 value)
EPICS_ALWAYS_INLINE void	putLong (std::size_t index, int64 value)
EPICS_ALWAYS_INLINE void	putFloat (std::size_t index, float value)
EPICS_ALWAYS_INLINE void	putDouble (std::size_t index, double value)
EPICS_ALWAYS_INLINE bool	getBoolean ()
EPICS_ALWAYS_INLINE int8	getByte ()
EPICS_ALWAYS_INLINE int16	getShort ()
EPICS_ALWAYS_INLINE int32	getInt ()
EPICS_ALWAYS_INLINE int64	getLong ()
EPICS_ALWAYS_INLINE float	getFloat ()
EPICS_ALWAYS_INLINE double	getDouble ()
EPICS_ALWAYS_INLINE bool	getBoolean (std::size_t index)
EPICS_ALWAYS_INLINE int8	getByte (std::size_t index)
EPICS_ALWAYS_INLINE int16	getShort (std::size_t index)
EPICS_ALWAYS_INLINE int32	getInt (std::size_t index)
EPICS_ALWAYS_INLINE int64	getLong (std::size_t index)
EPICS_ALWAYS_INLINE float	getFloat (std::size_t index)
EPICS_ALWAYS_INLINE double	getDouble (std::size_t index)
EPICS_ALWAYS_INLINE const char *	getArray () const EPICS_DEPRECATED
template<>
EPICS_ALWAYS_INLINE bool	reverse () const
template<>
EPICS_ALWAYS_INLINE bool	reverse () const
template<>
EPICS_ALWAYS_INLINE bool	reverse () const
template<>
EPICS_ALWAYS_INLINE bool	reverse () const
template<>
EPICS_ALWAYS_INLINE bool	reverse () const

Detailed Description

This class implements a Bytebuffer that is like the java.nio.ByteBuffer.

A BitSet is not safe for multithreaded use without external synchronization.

Based on Java implementation.

Definition at line 233 of file byteBuffer.h.

Constructor & Destructor Documentation

epics::pvData::ByteBuffer::ByteBuffer ( std::size_t  size, int  byteOrder = EPICS_BYTE_ORDER  )

inline

Constructor.

Parameters

size	The number of bytes.
byteOrder	The byte order. Must be one of EPICS_BYTE_ORDER,EPICS_ENDIAN_LITTLE,EPICS_ENDIAN_BIG.

Definition at line 243 of file byteBuffer.h.

                                                                 :
        _buffer((char*)std::malloc(size)), _size(size),
        _reverseEndianess(byteOrder != EPICS_BYTE_ORDER),
        _reverseFloatEndianess(byteOrder != EPICS_FLOAT_WORD_ORDER),
        _wrapped(false)
    {
        if(!_buffer)
            throw std::bad_alloc();
        clear();
    }

epics::pvData::ByteBuffer::ByteBuffer ( char *  buffer, std::size_t  size, int  byteOrder = EPICS_BYTE_ORDER  )

inline

Constructor for wrapping an existing buffer. Given buffer will not be released by the ByteBuffer instance.

Parameters

buffer	Existing buffer. May not be NULL.
size	The number of bytes.
byteOrder	The byte order. Must be one of EPICS_BYTE_ORDER,EPICS_ENDIAN_LITTLE,EPICS_ENDIAN_BIG.

Definition at line 262 of file byteBuffer.h.

                                                                               :
        _buffer(buffer), _size(size),
        _reverseEndianess(byteOrder != EPICS_BYTE_ORDER),
        _reverseFloatEndianess(byteOrder != EPICS_FLOAT_WORD_ORDER),
        _wrapped(true)
    {
        if(!_buffer)
            throw std::invalid_argument("ByteBuffer can't be constructed with NULL");
        clear();
    }

epics::pvData::ByteBuffer::~ByteBuffer ( )

inline

Destructor

Definition at line 275 of file byteBuffer.h.

    {
        if (_buffer && !_wrapped) std::free(_buffer);
    }

Member Function Documentation

void epics::pvData::ByteBuffer::align ( std::size_t  size, char  fill = '\0'  )

inline

Adjust position to the next multiple of 'size.

Parameters

size	The alignment requirement, must be a power of 2. (unchecked)
fill	value to use for padding bytes (default '\0').

Note

This alignment is absolute, not necessarily with respect to _buffer.

Definition at line 504 of file byteBuffer.h.

    {
        const std::size_t k = size - 1, bufidx = (std::size_t)_position;
        if(bufidx&k) {
            std::size_t npad = size-(bufidx&k);
            assert(npad<=getRemaining());
            std::fill(_position, _position+npad, fill);
            _position += npad;
        }
    }

void epics::pvData::ByteBuffer::clear ( )

inline

Makes a buffer ready for a new sequence of channel-read or relative put operations: It sets the limit to the capacity and the position to zero.

Definition at line 302 of file byteBuffer.h.

    {
        _position = _buffer;
        _limit = _buffer + _size;
    }

void epics::pvData::ByteBuffer::flip ( )

inline

Makes a buffer ready to read out previously written values.

Typically _limit==_buffer+_size is the initial state, but this is not required.

V _buffer V _position V _limit V _buffer+_size |_______written_______|____uninitialized___|____allocated___|

becomes

V _buffer/_position V _limit V _buffer+size |_______written_______|________________allocated____________|

Definition at line 321 of file byteBuffer.h.

                       {
        _limit = _position;
        _position = _buffer;
    }

template<typename T >

T epics::pvData::ByteBuffer::get ( )

inline

Get the new object from the byte buffer. The item MUST have type T. The position is adjusted based on the type.

Returns

The object.

Definition at line 775 of file byteBuffer.h.

    {
        assert(sizeof(T)<=getRemaining());

        T value = detail::load_unaligned<T>(_position);
        _position += sizeof(T);

        if(reverse<T>())
            value = swap<T>(value);
        return value;
    }

template<typename T >

T epics::pvData::ByteBuffer::get ( std::size_t  index ) const

inline

Get the new object from the byte buffer at the specified index. The item MUST have type T. The position is adjusted based on the type.

Parameters

index

The location in the byte buffer.

Returns

The object.

Definition at line 789 of file byteBuffer.h.

    {
        assert(_buffer+index<=_limit);

        T value = detail::load_unaligned<T>(_buffer + index);

        if(reverse<T>())
            value = swap<T>(value);
        return value;
    }

void epics::pvData::ByteBuffer::get ( char *  dest, std::size_t  dest_offset, std::size_t  count  )

inline

Get a sub-array of bytes from the byte buffer. The position is increased by the count.

Parameters

dest	The destination array.
dest_offset	The starting position within src.
count	The number of bytes to put into the byte buffer. Must be less than getRemaining()

Definition at line 465 of file byteBuffer.h.

                                                                        {
        assert(count<=getRemaining());
        memcpy(dest + dest_offset, _position, count);
        _position += count;
    }

template<typename T >

void epics::pvData::ByteBuffer::getArray ( T *  values, std::size_t  count  )

inline

Get an array of type T from the byte buffer. The position is adjusted.

Parameters

values	The destination array.
count	The number of elements.

Definition at line 817 of file byteBuffer.h.

    {
        size_t n = sizeof(T)*count; // bytes
        assert(n<=getRemaining());

        if (reverse<T>()) {
            for(std::size_t i=0; i<count; i++) {
                values[i] = swap<T>(detail::load_unaligned<T>(_position+i*sizeof(T)));
            }
        } else {
            memcpy(values, _position, n);
        }
        _position += n;
    }

EPICS_ALWAYS_INLINE const char* epics::pvData::ByteBuffer::getArray ( ) const

inline

Definition at line 699 of file byteBuffer.h.

    {
        return _buffer;
    }

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::getBoolean ( )

inline

Get a boolean value from the byte buffer.

Returns

The value.

Definition at line 611 of file byteBuffer.h.

{ return GET(  int8) != 0; }

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::getBoolean ( std::size_t  index )

inline

Get a boolean value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 654 of file byteBuffer.h.

{ return get<  int8>(index) != 0; }

const char* epics::pvData::ByteBuffer::getBuffer ( ) const

inline

Get the raw buffer data.

Returns

the raw buffer data.

Definition at line 294 of file byteBuffer.h.

    {
        return _buffer;
    }

EPICS_ALWAYS_INLINE int8 epics::pvData::ByteBuffer::getByte ( )

inline

Get a byte value from the byte buffer.

Returns

The value.

Definition at line 617 of file byteBuffer.h.

{ return GET(  int8); }

EPICS_ALWAYS_INLINE int8 epics::pvData::ByteBuffer::getByte ( std::size_t  index )

inline

Get a byte value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 661 of file byteBuffer.h.

{ return get<  int8>(index); }

EPICS_ALWAYS_INLINE double epics::pvData::ByteBuffer::getDouble ( )

inline

Get a double value from the byte buffer.

Returns

The value.

Definition at line 647 of file byteBuffer.h.

{ return GET(double); }

EPICS_ALWAYS_INLINE double epics::pvData::ByteBuffer::getDouble ( std::size_t  index )

inline

Get a boolean value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 696 of file byteBuffer.h.

{ return get<double>(index); }

EPICS_ALWAYS_INLINE float epics::pvData::ByteBuffer::getFloat ( )

inline

Get a float value from the byte buffer.

Returns

The value.

Definition at line 641 of file byteBuffer.h.

{ return GET( float); }

EPICS_ALWAYS_INLINE float epics::pvData::ByteBuffer::getFloat ( std::size_t  index )

inline

Get a float value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 689 of file byteBuffer.h.

{ return get< float>(index); }

EPICS_ALWAYS_INLINE int32 epics::pvData::ByteBuffer::getInt ( )

inline

Get a int value from the byte buffer.

Returns

The value.

Definition at line 629 of file byteBuffer.h.

{ return GET( int32); }

EPICS_ALWAYS_INLINE int32 epics::pvData::ByteBuffer::getInt ( std::size_t  index )

inline

Get an int value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 675 of file byteBuffer.h.

{ return get< int32>(index); }

std::size_t epics::pvData::ByteBuffer::getLimit ( ) const

inline

Returns this buffer's limit.

Returns

The offset into the raw buffer.

Definition at line 368 of file byteBuffer.h.

    {
        return _limit - _buffer;
    }

EPICS_ALWAYS_INLINE int64 epics::pvData::ByteBuffer::getLong ( )

inline

Get a long value from the byte buffer.

Returns

The value.

Definition at line 635 of file byteBuffer.h.

{ return GET( int64); }

EPICS_ALWAYS_INLINE int64 epics::pvData::ByteBuffer::getLong ( std::size_t  index )

inline

Get a long value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 682 of file byteBuffer.h.

{ return get< int64>(index); }

std::size_t epics::pvData::ByteBuffer::getPosition ( ) const

inline

Returns the current position.

Returns

The current position in the raw data.

Definition at line 346 of file byteBuffer.h.

    {
        return _position - _buffer;
    }

std::size_t epics::pvData::ByteBuffer::getRemaining ( ) const

inline

Returns the number of elements between the current position and the limit.

Returns

The number of elements remaining in this buffer.

Definition at line 391 of file byteBuffer.h.

    {
        return _limit - _position;
    }

EPICS_ALWAYS_INLINE int16 epics::pvData::ByteBuffer::getShort ( )

inline

Get a short value from the byte buffer.

Returns

The value.

Definition at line 623 of file byteBuffer.h.

{ return GET( int16); }

EPICS_ALWAYS_INLINE int16 epics::pvData::ByteBuffer::getShort ( std::size_t  index )

inline

Get a short value from the byte buffer at the specified index.

Parameters

index

The offset in the byte buffer.

Returns

The value.

Definition at line 668 of file byteBuffer.h.

{ return get< int16>(index); }

EPICS_ALWAYS_INLINE std::size_t epics::pvData::ByteBuffer::getSize ( ) const

inline

Returns The size, i.e. capacity of the raw data buffer in bytes.

Returns

The size of the raw data buffer.

Definition at line 400 of file byteBuffer.h.

    {
        return _size;
    }

template<typename T >

void epics::pvData::ByteBuffer::put ( T  value )

inline

Put the value into the raw buffer as a byte stream in the current byte order.

Parameters

value

The value to be put into the byte buffer.

Definition at line 748 of file byteBuffer.h.

    {
        assert(sizeof(T)<=getRemaining());

        if(reverse<T>())
            value = swap<T>(value);

        detail::store_unaligned(_position, value);
        _position += sizeof(T);
    }

template<typename T >

void epics::pvData::ByteBuffer::put ( std::size_t  index, T  value  ) const

inline

Put the value into the raw buffer at the specified index as a byte stream in the current byte order.

Parameters

index	Offset in the byte buffer.
value	The value to be put into the byte buffer.

Definition at line 760 of file byteBuffer.h.

    {
        assert(_buffer+index<=_limit);

        if(reverse<T>())
            value = swap<T>(value);

        detail::store_unaligned(_buffer+index, value);
    }

void epics::pvData::ByteBuffer::put ( const char *  src, std::size_t  src_offset, std::size_t  count  )

inline

Put a sub-array of bytes into the byte buffer. The position is increased by the count.

Parameters

src	The source array.
src_offset	The starting position within src.
count	The number of bytes to put into the byte buffer. Must be less than getRemaining()

Definition at line 451 of file byteBuffer.h.

                                                                            {
        assert(count<=getRemaining());
        memcpy(_position, src + src_offset, count);
        _position += count;
    }

template<typename T >

void epics::pvData::ByteBuffer::putArray ( const T *  values, std::size_t  count  )

inline

Put an array of type T into the byte buffer. The position is adjusted.

Parameters

values	The input array.
count	The number of elements.

Definition at line 801 of file byteBuffer.h.

    {
        size_t n = sizeof(T)*count; // bytes
        assert(n<=getRemaining());

        if (reverse<T>()) {
            for(std::size_t i=0; i<count; i++) {
                detail::store_unaligned(_position+i*sizeof(T), swap<T>(values[i]));
            }
        } else {
            memcpy(_position, values, n);
        }
        _position += n;
    }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putBoolean ( bool  value )

inline

Put a boolean value into the byte buffer.

Parameters

value

The value.

Definition at line 519 of file byteBuffer.h.

{ put<  int8>(value ? 1 : 0); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putBoolean ( std::size_t  index, bool  value  )

inline

Put a boolean value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 563 of file byteBuffer.h.

{ put<  int8>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putByte ( int8  value )

inline

Put a byte value into the byte buffer.

Parameters

value

The value.

Definition at line 525 of file byteBuffer.h.

{ put<  int8>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putByte ( std::size_t  index, int8  value  )

inline

Put a byte value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 570 of file byteBuffer.h.

{ put<  int8>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putDouble ( double  value )

inline

Put a double value into the byte buffer.

Parameters

value

The value.

Definition at line 555 of file byteBuffer.h.

{ put<double>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putDouble ( std::size_t  index, double  value  )

inline

Put a double value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 605 of file byteBuffer.h.

{ put<double>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putFloat ( float  value )

inline

Put a float value into the byte buffer.

Parameters

value

The value.

Definition at line 549 of file byteBuffer.h.

{ put< float>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putFloat ( std::size_t  index, float  value  )

inline

Put a float value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 598 of file byteBuffer.h.

{ put< float>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putInt ( int32  value )

inline

Put an int value into the byte buffer.

Parameters

value

The value.

Definition at line 537 of file byteBuffer.h.

{ put< int32>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putInt ( std::size_t  index, int32  value  )

inline

Put an int value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 584 of file byteBuffer.h.

{ put< int32>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putLong ( int64  value )

inline

Put a long value into the byte buffer.

Parameters

value

The value.

Definition at line 543 of file byteBuffer.h.

{ put< int64>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putLong ( std::size_t  index, int64  value  )

inline

Put a long value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 591 of file byteBuffer.h.

{ put< int64>(index, value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putShort ( int16  value )

inline

Put a short value into the byte buffer.

Parameters

value

The value.

Definition at line 531 of file byteBuffer.h.

{ put< int16>(value); }

EPICS_ALWAYS_INLINE void epics::pvData::ByteBuffer::putShort ( std::size_t  index, int16  value  )

inline

Put a short value into the byte buffer at the specified index.

Parameters

index	The offset in the byte buffer,
value	The value.

Definition at line 577 of file byteBuffer.h.

{ put< int16>(index, value); }

template<typename T >

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse ( ) const

inline

Is the byte order the EPICS_BYTE_ORDER

Returns

(false,true) if (is, is not) the EPICS_BYTE_ORDER

Definition at line 493 of file byteBuffer.h.

    {
        return sizeof(T)>1 && _reverseEndianess;
    }

template<>

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse

(

)

const

Definition at line 716 of file byteBuffer.h.

    {
        return false;
    }

template<>

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse

(

)

const

Definition at line 722 of file byteBuffer.h.

    {
        return false;
    }

template<>

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse

(

)

const

Definition at line 728 of file byteBuffer.h.

    {
        return false;
    }

template<>

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse

(

)

const

Definition at line 734 of file byteBuffer.h.

    {
        return _reverseFloatEndianess;
    }

template<>

EPICS_ALWAYS_INLINE bool epics::pvData::ByteBuffer::reverse

(

)

const

Definition at line 740 of file byteBuffer.h.

    {
        return _reverseFloatEndianess;
    }

void epics::pvData::ByteBuffer::rewind ( )

inline

Makes a buffer ready for re-reading the data that it already contains: It leaves the limit unchanged and sets the position to zero.

Note that this may allow reading of uninitialized values. flip() should be considered

V _buffer V _position V _limit V _buffer+_size |_______written_______|____uninitialized___|____allocated___|

becomes

V _buffer/_position V _limit V _buffer+size |_______written_______|____uninitialized___|____allocated___|

Definition at line 339 of file byteBuffer.h.

                         {
        _position = _buffer;
    }

void epics::pvData::ByteBuffer::setEndianess ( int  byteOrder )

inline

Set the byte order.

Parameters

byteOrder

The byte order. Must be one of EPICS_BYTE_ORDER,EPICS_ENDIAN_LITTLE,EPICS_ENDIAN_BIG,

Definition at line 285 of file byteBuffer.h.

    {
        _reverseEndianess = (byteOrder != EPICS_BYTE_ORDER);
        _reverseFloatEndianess = (byteOrder != EPICS_FLOAT_WORD_ORDER);
    }

void epics::pvData::ByteBuffer::setLimit ( std::size_t  limit )

inline

Sets this buffer's limit. If the position is larger than the new limit then it is set to the new limit.s If the mark is defined and larger than the new limit then it is discarded.

Parameters

limit

The new position value; must be no larger than the current limit

Definition at line 380 of file byteBuffer.h.

    {
        assert(limit<=_size);
        _limit = _buffer + limit;
        assert(_position<=_limit);
    }

void epics::pvData::ByteBuffer::setPosition ( std::size_t  pos )

inline

Sets the buffer position. If the mark is defined and larger than the new position then it is discarded.

Parameters

pos	The offset into the raw buffer. The new position value; must be no larger than the current limit

Definition at line 357 of file byteBuffer.h.

    {
        assert(pos<=_size);
        _position = _buffer + pos;
        assert(_position<=_limit);
    }

---

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

• modules/pvData/src/misc/pv/byteBuffer.h