diff options
Diffstat (limited to 'qpid/dotnet/Qpid.Buffer')
| -rw-r--r-- | qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs | 380 | ||||
| -rw-r--r-- | qpid/dotnet/Qpid.Buffer/HeapByteBuffer.cs | 473 |
2 files changed, 853 insertions, 0 deletions
diff --git a/qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs b/qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs new file mode 100644 index 0000000000..30d51b6d9e --- /dev/null +++ b/qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs @@ -0,0 +1,380 @@ +/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using System;
+
+namespace Qpid.Buffer
+{
+ /// <summary>
+ /// A FixedByteBuffer is for ....
+ ///
+ /// <para/>Todo: Seems to wrap a HeapByteBuffer and add more its method signature, other than that, seems pointless. Push down the extra methods
+ /// onto HeapByteBuffer and get rid of this altoghether? (Or pull heap byte buffer up into this class and get rid of it).
+ ///
+ /// <para/>Todo: Name methods using C# conventions.
+ ///
+ /// </summary>
+ public class FixedByteBuffer
+ {
+ private HeapByteBuffer _buf;
+
+ /// <summary>
+ /// Creates a fixed
+ /// </summary>
+ /// <param name="capacity"></param>
+ public FixedByteBuffer(int capacity)
+ {
+ _buf = new HeapByteBuffer(capacity);
+ }
+
+ public FixedByteBuffer(byte[] bytes)
+ {
+ _buf = HeapByteBuffer.wrap(bytes);
+ }
+
+ public static FixedByteBuffer wrap(byte[] array)
+ {
+ return new FixedByteBuffer(array);
+ }
+
+ public static FixedByteBuffer wrap(byte[] array, int offset, int length)
+ {
+ throw new NotImplementedException();
+ }
+
+ public ByteOrder order()
+ {
+ return ByteOrder.LittleEndian;
+ }
+
+ public void order(ByteOrder bo)
+ {
+ // Ignore endianess.
+ }
+
+ public void compact()
+ {
+ _buf.Compact();
+ }
+
+ public char getChar()
+ {
+ throw new NotImplementedException();
+ }
+
+ public char getChar(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putChar(char value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putChar(int index, char value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public bool isDirect()
+ {
+ return false;
+ }
+
+ public bool isReadOnly()
+ {
+ throw new NotImplementedException();
+ }
+
+ public int capacity()
+ {
+ return _buf.Capacity;
+ }
+
+ public int limit()
+ {
+ return _buf.Limit;
+ }
+
+ public int limit(int limit)
+ {
+ int previousLimit = _buf.Limit;
+ _buf.Limit = limit;
+ return previousLimit;
+ }
+
+ public int position()
+ {
+ return _buf.Position;
+ }
+
+ public int position(int newPosition)
+ {
+ int prev = _buf.Position;
+ _buf.Position = newPosition;
+ return prev;
+ }
+
+ public void mark()
+ {
+ throw new NotImplementedException();
+ }
+
+ public static FixedByteBuffer allocateDirect(int capacity)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static FixedByteBuffer allocate(int capacity)
+ {
+ return new FixedByteBuffer(capacity);
+ }
+
+ public void clear()
+ {
+ _buf.Clear();
+ }
+
+ public void put(byte b)
+ {
+ _buf.Put(b);
+ }
+
+ public void put(int index, byte b)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void put(FixedByteBuffer buf)
+ {
+ _buf.Put(buf.array(), buf.position(), buf.limit() - buf.position());
+ }
+
+ public FixedByteBuffer duplicate()
+ {
+ throw new NotImplementedException();
+ }
+
+ public FixedByteBuffer slice()
+ {
+ throw new NotImplementedException();
+ }
+
+ public FixedByteBuffer asReadOnlyBuffer()
+ {
+ throw new NotImplementedException();
+ }
+
+ /// <summary>
+ /// Returns backing array.
+ /// </summary>
+ /// <returns></returns>
+ public byte[] array()
+ {
+ return _buf.array();
+ }
+
+ public int arrayOffset()
+ {
+ throw new NotImplementedException();
+ }
+
+ public void reset()
+ {
+ throw new NotImplementedException();
+ }
+
+ public void flip()
+ {
+ _buf.Flip();
+ }
+
+ public void rewind()
+ {
+ _buf.Rewind();
+ }
+
+ public byte get()
+ {
+ return _buf.Get();
+ }
+
+ public byte get(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public short getShort()
+ {
+ return _buf.GetShort();
+ }
+
+ public short getShort(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putShort(short value)
+ {
+ _buf.Put(value);
+ }
+
+ public void putShort(int index, short value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public int getInt()
+ {
+ return _buf.GetInt();
+ }
+
+ public int getInt(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putInt(int value)
+ {
+ _buf.Put(value);
+ }
+
+ public void putInt(int index, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public ByteBuffer get(byte[] dst, int offset, int length)
+ {
+ throw new NotImplementedException();
+ }
+
+ public ByteBuffer put(byte[] src, int offset, int length)
+ {
+ throw new NotImplementedException();
+ }
+
+ public long getLong()
+ {
+ return _buf.GetLong();
+ }
+
+ public long getLong(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putLong(long value)
+ {
+ _buf.Put(value);
+ }
+
+ public void putLong(int index, long value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public int remaining()
+ {
+ return _buf.Remaining;
+ }
+
+ public float getFloat()
+ {
+ return _buf.GetFloat();
+ }
+
+ public float getFloat(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putFloat(float value)
+ {
+ _buf.Put(value);
+ }
+
+ public void putFloat(int index, float value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public double getDouble()
+ {
+ return _buf.GetDouble();
+ }
+
+ public double getDouble(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+ public void putDouble(double value)
+ {
+ _buf.Put(value);
+ }
+
+ public void putDouble(int index, double value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public ushort getUnsignedShort()
+ {
+ return _buf.GetUnsignedShort();
+ }
+
+ public uint getUnsignedInt()
+ {
+ return _buf.GetUnsignedInt();
+ }
+
+ public void get(byte[] dst)
+ {
+ _buf.Get(dst);
+ }
+
+ public void put(ushort value)
+ {
+ _buf.Put(value);
+ }
+
+ public void put(uint max)
+ {
+ _buf.Put(max);
+ }
+
+ public void put(ulong tag)
+ {
+ _buf.Put(tag);
+ }
+
+ public void put(byte[] src)
+ {
+ _buf.Put(src);
+ }
+
+ public ulong getUnsignedLong()
+ {
+ return _buf.GetUnsignedLong();
+ }
+ }
+}
diff --git a/qpid/dotnet/Qpid.Buffer/HeapByteBuffer.cs b/qpid/dotnet/Qpid.Buffer/HeapByteBuffer.cs new file mode 100644 index 0000000000..add8e2e80c --- /dev/null +++ b/qpid/dotnet/Qpid.Buffer/HeapByteBuffer.cs @@ -0,0 +1,473 @@ +/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using System;
+using System.Text;
+
+namespace Qpid.Buffer
+{
+ /// <summary>
+ ///
+ /// </summary>
+ public class HeapByteBuffer //: ByteBuffer
+ {
+ private byte[] _underlyingData;
+
+ /// <summary> The current position within the buffer where the next value to be read or written will occurr. </summary>
+ private int _position;
+
+ /// <summary> The index of the first element that should not be read or written. </summary>
+ private int _limit;
+
+ public HeapByteBuffer(int size) : this(new byte[size], 0)
+ {
+ }
+
+ private HeapByteBuffer(byte[] bytes, int length)
+ {
+ _underlyingData = bytes;
+ _limit = bytes.Length;
+ _position = length;
+ }
+
+ public /*override*/ int Capacity
+ {
+ get
+ {
+ return _underlyingData.Length;
+ }
+ }
+
+ public /*override*/ int Position
+ {
+ get
+ {
+ return _position;
+ }
+ set
+ {
+ _position = value;
+ }
+ }
+
+ /// <summary>
+ /// Sets this buffer's limit. If the position is larger than the new limit then it is set to the new limit.
+ /// </summary>
+ /// <value>The new limit value; must be non-negative and no larger than this buffer's capacity</value>
+ public /*override*/ int Limit
+ {
+ get
+ {
+ return _limit;
+ }
+ set
+ {
+ if (value < 0)
+ {
+ throw new ArgumentException("Limit must not be negative");
+ }
+ if (value > Capacity)
+ {
+ throw new ArgumentException("Limit must not be greater than Capacity");
+ }
+ _limit = value;
+ if (_position > value)
+ {
+ _position = value;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Returns the number of elements between the current position and the limit
+ /// </summary>
+ /// <value>The number of elements remaining in this buffer</value>
+ public /*override*/ int Remaining
+ {
+ get
+ {
+ return (_limit - _position);
+ }
+ }
+
+ public /*override*/ void Clear()
+ {
+ _position = 0;
+ _limit = Capacity;
+ }
+
+ public /*override*/ void Flip()
+ {
+ _limit = _position;
+ _position = 0;
+ }
+
+ public /*override*/ void Rewind()
+ {
+ _position = 0;
+ }
+
+ public byte[] array()
+ {
+ return _underlyingData;
+ }
+
+ public /*override*/ byte[] ToByteArray()
+ {
+ // Return copy of bytes remaining.
+ byte[] result = new byte[Remaining];
+ Array.Copy(_underlyingData, _position, result, 0, Remaining);
+ return result;
+ }
+
+ private void CheckSpace(int size)
+ {
+ if (_position + size > _limit)
+ {
+ throw new BufferOverflowException("Attempt to write " + size + " byte(s) to buffer where position is " + _position +
+ " and limit is " + _limit);
+ }
+ }
+
+ private void CheckSpaceForReading(int size)
+ {
+ if (_position + size > _limit)
+ {
+ throw new BufferUnderflowException("Attempt to read " + size + " byte(s) to buffer where position is " + _position +
+ " and limit is " + _limit);
+ }
+ }
+
+ /// <summary>
+ /// Writes the given byte into this buffer at the current position, and then increments the position.
+ /// </summary>
+ /// <param name="data">The byte to be written</param>
+ /// <exception cref="BufferOverflowException">If this buffer's current position is not smaller than its limit</exception>
+ public /*override*/ void Put(byte data)
+ {
+ CheckSpace(1);
+ _underlyingData[_position++] = data;
+ }
+
+ /// <summary>
+ /// Writes all the data in the given byte array into this buffer at the current
+ /// position and then increments the position.
+ /// </summary>
+ /// <param name="data">The data to copy.</param>
+ /// <exception cref="BufferOverflowException">If this buffer's current position plus the array length is not smaller than its limit</exception>
+ public /*override*/ void Put(byte[] data)
+ {
+ Put(data, 0, data.Length);
+ }
+
+ public /*override*/ void Put(byte[] data, int offset, int size)
+ {
+ if (data == null)
+ {
+ throw new ArgumentNullException("data");
+ }
+ CheckSpace(size);
+ Array.Copy(data, offset, _underlyingData, _position, size);
+ _position += size;
+ }
+
+ /// <summary>
+ /// Writes the given ushort into this buffer at the current position, and then increments the position.
+ /// </summary>
+ /// <param name="data">The ushort to be written</param>
+ public /*override*/ void Put(ushort data)
+ {
+ CheckSpace(2);
+ _underlyingData[_position++] = (byte) (data >> 8);
+ _underlyingData[_position++] = (byte) data;
+ }
+
+ public /*override*/ void Put(uint data)
+ {
+ CheckSpace(4);
+ _underlyingData[_position++] = (byte) (data >> 24);
+ _underlyingData[_position++] = (byte) (data >> 16);
+ _underlyingData[_position++] = (byte) (data >> 8);
+ _underlyingData[_position++] = (byte) data;
+ }
+
+ public /*override*/ void Put(ulong data)
+ {
+ CheckSpace(8);
+ _underlyingData[_position++] = (byte) (data >> 56);
+ _underlyingData[_position++] = (byte) (data >> 48);
+ _underlyingData[_position++] = (byte) (data >> 40);
+ _underlyingData[_position++] = (byte) (data >> 32);
+ _underlyingData[_position++] = (byte) (data >> 24);
+ _underlyingData[_position++] = (byte) (data >> 16);
+ _underlyingData[_position++] = (byte) (data >> 8);
+ _underlyingData[_position++] = (byte) data;
+ }
+
+ public void Put(short data)
+ {
+ Put((ushort)data);
+ }
+
+ public void Put(int data)
+ {
+ Put((uint)data);
+ }
+
+ public void Put(long data)
+ {
+ Put((ulong)data);
+ }
+
+ public void Put(float data)
+ {
+ unsafe
+ {
+ uint val = *((uint*)&data);
+ Put(val);
+ }
+ }
+
+ public void Put(double data)
+ {
+ unsafe
+ {
+ ulong val = *((ulong*)&data);
+ Put(val);
+ }
+ }
+
+
+ /// <summary>
+ /// Read the byte at the current position and increment the position
+ /// </summary>
+ /// <returns>a byte</returns>
+ /// <exception cref="BufferUnderflowException">if there are no bytes left to read</exception>
+ public /*override*/ byte Get()
+ {
+ CheckSpaceForReading(1);
+ return _underlyingData[_position++];
+ }
+
+ /// <summary>
+ /// Reads bytes from the buffer into the supplied array
+ /// </summary>
+ /// <param name="destination">The destination array. The array must not
+ /// be bigger than the remaining space in the buffer, nor can it be null.</param>
+ public /*override*/ void Get(byte[] destination)
+ {
+ if (destination == null)
+ {
+ throw new ArgumentNullException("destination");
+ }
+ int len = destination.Length;
+ CheckSpaceForReading(len);
+ Array.Copy(_underlyingData, _position, destination, 0, len);
+ _position += len;
+ }
+
+ /// <summary>
+ /// Reads and returns an unsigned short (two bytes, big endian) from this buffer
+ /// </summary>
+ /// <returns>an unsigned short</returns>
+ /// <exception cref="BufferUnderflowException">If there are fewer than two bytes remaining in this buffer</exception>
+ public /*override*/ ushort GetUnsignedShort()
+ {
+ CheckSpaceForReading(2);
+ byte upper = _underlyingData[_position++];
+ byte lower = _underlyingData[_position++];
+ return (ushort) ((upper << 8) + lower);
+ }
+
+ /// <summary>
+ /// Reads and returns an unsigned int (four bytes, big endian) from this buffer
+ /// </summary>
+ /// <returns>an unsigned integer</returns>
+ /// <exception cref="BufferUnderflowException">If there are fewer than four bytes remaining in this buffer</exception>
+ public /*override*/ uint GetUnsignedInt()
+ {
+ CheckSpaceForReading(4);
+ byte b1 = _underlyingData[_position++];
+ byte b2 = _underlyingData[_position++];
+ byte b3 = _underlyingData[_position++];
+ byte b4 = _underlyingData[_position++];
+ return (uint) ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
+ }
+
+ public /*override*/ ulong GetUnsignedLong()
+ {
+ CheckSpaceForReading(8);
+ byte b1 = _underlyingData[_position++];
+ byte b2 = _underlyingData[_position++];
+ byte b3 = _underlyingData[_position++];
+ byte b4 = _underlyingData[_position++];
+ byte b5 = _underlyingData[_position++];
+ byte b6 = _underlyingData[_position++];
+ byte b7 = _underlyingData[_position++];
+ byte b8 = _underlyingData[_position++];
+ // all the casts necessary because otherwise each subexpression
+ // only gets promoted to uint and cause incorrect results
+ return (((ulong)b1 << 56) + ((ulong)b2 << 48) + ((ulong)b3 << 40) +
+ ((ulong)b4 << 32) + ((ulong)b5 << 24) +
+ ((ulong)b6 << 16) + ((ulong)b7 << 8) + b8);
+ }
+
+ public short GetShort()
+ {
+ return (short) GetUnsignedShort();
+ }
+
+ public int GetInt()
+ {
+ return (int) GetUnsignedInt();
+ }
+
+ public long GetLong()
+ {
+ return (long) GetUnsignedLong();
+ }
+
+ public float GetFloat()
+ {
+ unsafe
+ {
+ uint val = GetUnsignedInt();
+ return *((float*)&val);
+ }
+ }
+
+ public double GetDouble()
+ {
+ unsafe
+ {
+ ulong val = GetUnsignedLong();
+ return *((double*)&val);
+ }
+ }
+
+ public /*override*/ string GetString(uint length, Encoding encoder)
+ {
+ CheckSpaceForReading((int)length);
+ string result = encoder.GetString(_underlyingData, _position, (int)length);
+ _position += (int)length;
+ return result;
+ }
+
+ public /*override*/ void Acquire()
+ {
+ }
+
+ public /*override*/ void Release()
+ {
+ }
+
+ public /*override*/ bool IsAutoExpand
+ {
+ get { return false; }
+ set { }
+ }
+
+ public /*override*/ void Expand(int expectedRemaining)
+ {
+ throw new NotImplementedException();
+ }
+
+ public /*override*/ void Expand(int pos, int expectedRemaining)
+ {
+ throw new NotImplementedException();
+ }
+
+ public /*override*/ bool Pooled
+ {
+ get { return false; }
+ set { }
+ }
+
+ public void Mark()
+ {
+ throw new NotImplementedException();
+ }
+
+ public void Reset()
+ {
+ throw new NotImplementedException();
+ }
+
+ public /*override*/ byte Get(int index)
+ {
+ throw new NotImplementedException();
+ }
+
+// public /*override*/ void Put(ByteBuffer src)
+// {
+// if (src == this)
+// {
+// throw new ArgumentException("Cannot copy self into self!");
+// }
+//
+// HeapByteBuffer sb;
+// if (src is HeapByteBuffer)
+// {
+// sb = (HeapByteBuffer) src;
+// }
+// else
+// {
+// sb = (HeapByteBuffer)((RefCountingByteBuffer) src).Buf;
+// }
+// int n = sb.Remaining;
+// if (n > Remaining)
+// {
+// throw new BufferOverflowException("Not enought capacity in this buffer for " + n + " elements - only " + Remaining + " remaining");
+// }
+// Array.Copy(sb._underlyingData, sb._position, _underlyingData, _position, n);
+// sb._position += n;
+// _position += n;
+// }
+
+ public /*override*/ void Compact()
+ {
+ if (Remaining > 0)
+ {
+ if (_position > 0)
+ {
+ Array.Copy(_underlyingData, _position, _underlyingData, 0, Remaining);
+ }
+ _position = Remaining;
+ }
+ else
+ {
+ _position = 0;
+ }
+ _limit = Capacity;
+ }
+
+ public static HeapByteBuffer wrap(byte[] bytes, int length)
+ {
+ return new HeapByteBuffer(bytes, length);
+ }
+
+ public static HeapByteBuffer wrap(byte[] bytes)
+ {
+ return new HeapByteBuffer(bytes, bytes.Length);
+ }
+ }
+}
+
+
|