diff options
Diffstat (limited to 'qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs')
| -rw-r--r-- | qpid/dotnet/Qpid.Buffer/FixedByteBuffer.cs | 380 |
1 files changed, 380 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();
+ }
+ }
+}
|