byteBuffer added

pvDataApp/misc/byteBuffer.cpp

@@ -0,0 +1,180 @@
+/*
+ * byteBuffer.cpp
+ *
+ *  Created on: Oct 18, 2010
+ *      Author: Miha Vitorovic
+ */
+
+#include "byteBuffer.h"
+#include "epicsException.h"
+
+namespace epics {
+    namespace pvData {
+
+        using std::stringstream;
+
+        ByteBuffer::ByteBuffer(int size, int byteOrder) :
+                _bufferByteOrder(byteOrder), _size(size), _position(0),
+                _limit(size), _buffer(0) {
+
+            if (size < 0)
+                throw EpicsException("negative size");
+
+            if (byteOrder!=EPICS_ENDIAN_BIG && byteOrder!=EPICS_ENDIAN_LITTLE)
+                throw EpicsException("invalid endian");
+
+            _buffer = new char[_size];
+        }
+
+        ByteBuffer::~ByteBuffer() {
+            if (_buffer) delete _buffer;
+        }
+
+        ByteBuffer* ByteBuffer::clear() {
+            _position = 0;
+            _limit = _size;
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::flip() {
+            _limit = _position;
+            _position = 0;
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::rewind() {
+            _position = 0;
+            return this;
+        }
+
+        bool ByteBuffer::getBoolean() {
+            if(_position<_limit)
+                return _buffer[_position++]==0 ? false : true;
+            else
+                throw EpicsException("buffer underflow");
+        }
+
+        epicsInt8 ByteBuffer::getByte() {
+            if(_position<_limit)
+                return (epicsInt8)_buffer[_position++];
+            else
+                throw EpicsException("buffer underflow");
+        }
+
+        epicsInt16 ByteBuffer::getShort() {
+            if(_limit-_position<(int)sizeof(epicsInt16))
+                throw EpicsException("buffer underflow");
+            epicsInt16 val;
+            getWithEndianness((char*)&val, sizeof(epicsInt16)); // store short into val
+            return val;
+        }
+
+        epicsInt32 ByteBuffer::getInt() {
+            if(_limit-_position<(int)sizeof(epicsInt32))
+                throw EpicsException("buffer underflow");
+            epicsInt32 val;
+            getWithEndianness((char*)&val, sizeof(epicsInt32)); // store int into val
+            return val;
+        }
+
+        epicsInt64 ByteBuffer::getLong() {
+            if(_limit-_position<(int)sizeof(epicsInt64))
+                throw EpicsException("buffer underflow");
+            epicsInt64 val;
+            getWithEndianness((char*)&val, sizeof(epicsInt64)); // store long into val
+            return val;
+        }
+
+        float ByteBuffer::getFloat() {
+            if(_limit-_position<(int)sizeof(float))
+                throw EpicsException("buffer underflow");
+            float val;
+            getWithEndianness((char*)&val, sizeof(float)); // store float into val
+            return val;
+        }
+
+        double ByteBuffer::getDouble() {
+            if(_limit-_position<(int)sizeof(double))
+                throw EpicsException("buffer underflow");
+            double val;
+            getWithEndianness((char*)&val, sizeof(double)); // store double into val
+            return val;
+        }
+
+        ByteBuffer* ByteBuffer::putBoolean(bool value) {
+            if(_position<_limit)
+                _buffer[_position++] = value ? 1 : 0;
+            else
+                throw EpicsException("buffer overflow");
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putByte(epicsInt8 value) {
+            if(_position<_limit)
+                _buffer[_position++] = (char)value;
+            else
+                throw EpicsException("buffer overflow");
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putShort(epicsInt16 value) {
+            if(_limit-_position<(int)sizeof(epicsInt16))
+                throw EpicsException("buffer overflow");
+            putWithEndianness((char*)&value, sizeof(epicsInt16)); // store short into buffer
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putInt(epicsInt32 value) {
+            if(_limit-_position<(int)sizeof(epicsInt32))
+                throw EpicsException("buffer overflow");
+            putWithEndianness((char*)&value, sizeof(epicsInt32)); // store int into buffer
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putLong(epicsInt64 value) {
+            if(_limit-_position<(int)sizeof(epicsInt64))
+                throw EpicsException("buffer overflow");
+            putWithEndianness((char*)&value, sizeof(epicsInt64)); // store long into buffer
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putFloat(float value) {
+            if(_limit-_position<(int)sizeof(float))
+                throw EpicsException("buffer overflow");
+            putWithEndianness((char*)&value, sizeof(float)); // store float into buffer
+            return this;
+        }
+
+        ByteBuffer* ByteBuffer::putDouble(double value) {
+            if(_limit-_position<(int)sizeof(double))
+                throw EpicsException("buffer overflow");
+            putWithEndianness((char*)&value, sizeof(double)); // store double into buffer
+            return this;
+        }
+
+        /**
+         * Buffer underflow or overflow checks are performed in the caller.
+         */
+        void ByteBuffer::getWithEndianness(char* dest, size_t size) {
+            if(_bufferByteOrder==EPICS_BYTE_ORDER)
+                for(size_t i = 0; i<size; i++)
+                    dest[i] = _buffer[_position++];
+            else
+                for(int i = (int)size-1; i>=0; i--)
+                    dest[i] = _buffer[_position++];
+        }
+
+        /**
+         * Buffer underflow or overflow checks are performed in the caller.
+         */
+        void ByteBuffer::putWithEndianness(char* src, size_t size) {
+            if(_bufferByteOrder==EPICS_BYTE_ORDER)
+                for(size_t i = 0; i<size; i++)
+                    _buffer[_position++] = src[i];
+            else
+                for(int i = (int)size-1; i>=0; i--)
+                    _buffer[_position++] = src[i];
+        }
+
+    }
+}