dotnet/client-010/client/transport/codec/AbstractDecoder.cs - qpid - Git at Google

 /*
 *
 * 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.Collections.Generic;
 using System.Diagnostics;
 using System.Text;
 using org.apache.qpid.transport.util;

 namespace org.apache.qpid.transport.codec
 {
     /// <summary>
     /// AbstractDecoder
     /// </summary>
     public abstract class AbstractDecoder : IDecoder
     {
         private readonly Dictionary<Binary, String> str8cache = new Dictionary<Binary, String>();

         protected abstract byte DoGet();

         protected abstract void DoGet(byte[] bytes);
         public abstract bool HasRemaining();

         protected byte Get()
         {
             return DoGet();
         }

         protected void Get(byte[] bytes)
         {
             DoGet(bytes);
         }

         protected Binary Get(int size)
         {
             byte[] bytes = new byte[size];
             Get(bytes);
             return new Binary(bytes);
         }

         protected short Uget()
         {
             return (short) (0xFF & Get());
         }

         public virtual short ReadUint8()
         {
             return Uget();
         }

         public abstract int ReadUint16();


         public abstract long ReadUint32();


         public int ReadSequenceNo()
         {
             return (int) ReadUint32();
         }

         public virtual long ReadUint64()
         {
             long l = 0;
             for (int i = 0; i < 8; i++)
             {
                 l |= ((long) (0xFF & Get())) << (56 - i*8);
             }
             return l;
         }

         public abstract short ReadInt8();
         public abstract int ReadInt16();
         public abstract long ReadInt32() ;
         public abstract long ReadInt64();
         public abstract float ReadFloat() ;
         public abstract double ReadDouble() ;

         public long ReadDatetime()
         {
             return ReadUint64();
         }

         private static String Decode(byte[] bytes, int offset, int length, Encoding encoding)
         {
             return encoding.GetString(bytes, offset, length);
         }

         private static String Decode(byte[] bytes, Encoding encoding)
         {
             return Decode(bytes, 0, bytes.Length, encoding);
         }

         public String ReadStr8()
         {
             short size = ReadUint8();
             Binary bin = Get(size);
             String str;
             if (! str8cache.TryGetValue(bin, out str))
             {
                 str = Decode(bin.Array(), bin.Offset(), bin.Size(), Encoding.UTF8);
                 str8cache.Add(bin, str);
             }
             return str;
         }

         public String ReadStr16()
         {
             int size = ReadUint16();
             byte[] bytes = new byte[size];
             Get(bytes);
             return Decode(bytes, Encoding.UTF8);
         }

         public byte[] ReadVbin8()
         {
             int size = ReadUint8();
             byte[] bytes = new byte[size];
             Get(bytes);
             return bytes;
         }

         public byte[] ReadVbin16()
         {
             int size = ReadUint16();
             byte[] bytes = new byte[size];
             Get(bytes);
             return bytes;
         }

         public byte[] ReadVbin32()
         {
             int size = (int) ReadUint32();
             byte[] bytes = new byte[size];
             Get(bytes);
             return bytes;
         }

         public RangeSet ReadSequenceSet()
         {
             int count = ReadUint16()/8;
             if (count == 0)
             {
                 return null;
             }
             RangeSet ranges = new RangeSet();
             for (int i = 0; i < count; i++)
             {
                 ranges.Add(ReadSequenceNo(), ReadSequenceNo());
             }
             return ranges;
         }

         public RangeSet ReadByteRanges()
         {
             throw new Exception("not implemented");
         }

         public UUID ReadUuid()
         {
             long msb = ReadUint64();
             long lsb = ReadUint64();
             return new UUID(msb, lsb);
         }

         public String ReadContent()
         {
             throw new Exception("Deprecated");
         }

         public Struct ReadStruct(int type)
         {
             Struct st = Struct.Create(type);
             int width = st.GetSizeWidth();
             if (width > 0)
             {
                 long size = ReadSize(width);
                 if (size == 0)
                 {
                     return null;
                 }
             }
             if (type > 0)
             {
                 int code = ReadUint16();
                 Debug.Assert(code == type);
             }
             st.Read(this);
             return st;
         }

         public Struct ReadStruct32()
         {
             long size = ReadUint32();
             if (size == 0)
             {
                 return null;
             }
             int type = ReadUint16();
             Struct result = Struct.Create(type);
             result.Read(this);
             return result;
         }

         public Dictionary<String, Object> ReadMap()
         {
             long size = ReadUint32();

             if (size == 0)
             {
                 return null;
             }

             long count = ReadUint32();

             Dictionary<String, Object> result = new Dictionary<String, Object>();
             for (int i = 0; i < count; i++)
             {
                 String key = ReadStr8();
                 byte code = Get();
                 QpidType t = GetType(code);
                 Object value = Read(t);
                 result.Add(key, value);
             }

             return result;
         }

         public List<Object> ReadList()
         {
             long size = ReadUint32();

             if (size == 0)
             {
                 return null;
             }

             long count = ReadUint32();

             List<Object> result = new List<Object>();
             for (int i = 0; i < count; i++)
             {
                 byte code = Get();
                 QpidType t = GetType(code);
                 Object value = Read(t);
                 result.Add(value);
             }
             return result;
         }

         public List<Object> ReadArray()
         {
             long size = ReadUint32();

             if (size == 0)
             {
                 return null;
             }

             byte code = Get();
             QpidType t = GetType(code);
             long count = ReadUint32();

             List<Object> result = new List<Object>();
             for (int i = 0; i < count; i++)
             {
                 Object value = Read(t);
                 result.Add(value);
             }
             return result;
         }

         private QpidType GetType(byte code)
         {
             return QpidType.get(code);
         }

         private long ReadSize(QpidType t)
         {
             return t.Fixed ? t.Width : ReadSize(t.Width);
         }

         private long ReadSize(int width)
         {
             switch (width)
             {
                 case 1:
                     return ReadUint8();
                 case 2:
                     return ReadUint16();
                 case 4:
                     return ReadUint32();
                 default:
                     throw new Exception("illegal width: " + width);
             }
         }

         private byte[] ReadBytes(QpidType t)
         {
             long size = ReadSize(t);
             byte[] result = new byte[(int) size];
             Get(result);
             return result;
         }

         private Object Read(QpidType t)
         {
             switch (t.Code)
             {
                 case Code.BIN8:
                 case Code.UINT8:
                     return ReadUint8();
                 case Code.INT8:
                     return Get();
                 case Code.CHAR:
                     return (char) Get();
                 case Code.BOOLEAN:
                     return Get() > 0;

                 case Code.BIN16:
                 case Code.UINT16:
                     return ReadUint16();
                 case Code.INT16:
                     return (short) ReadUint16();

                 case Code.BIN32:
                 case Code.UINT32:
                     return ReadUint32();

                 case Code.CHAR_UTF32:
                 case Code.INT32:
                     return (int) ReadUint32();

                 case Code.FLOAT:
                     return  (float)BitConverter.Int64BitsToDouble(ReadUint32() << 32);

                 case Code.BIN64:
                 case Code.UINT64:
                 case Code.INT64:
                 case Code.DATETIME:
                     return ReadUint64();

                 case Code.DOUBLE:
                     return BitConverter.Int64BitsToDouble(ReadUint64());
                 case Code.UUID:
                     return ReadUuid();
                 case Code.STR8:
                     return ReadStr8();
                 case Code.STR16:
                     return ReadStr16();
                 case Code.STR8_LATIN:
                 case Code.STR8_UTF16:
                 case Code.STR16_LATIN:
                 case Code.STR16_UTF16:
                     // XXX: need to do character conversion
                     return Encoding.UTF8.GetString(ReadBytes(t));

                 case Code.MAP:
                     return ReadMap();
                 case Code.LIST:
                     return ReadList();
                 case Code.ARRAY:
                     return ReadArray();
                 case Code.STRUCT32:
                     return ReadStruct32();

                 case Code.BIN40:
                 case Code.DEC32:
                 case Code.BIN72:
                 case Code.DEC64:
                     // XXX: what types are we supposed to use here?
                     return ReadBytes(t);

                 case Code.VOID:
                     return null;

                 default:
                     return ReadBytes(t);
             }
         }
     }
 }
	/*
	*
	* 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.Collections.Generic;
	using System.Diagnostics;
	using System.Text;
	using org.apache.qpid.transport.util;

	namespace org.apache.qpid.transport.codec
	{
	/// <summary>
	/// AbstractDecoder
	/// </summary>
	public abstract class AbstractDecoder : IDecoder
	{
	private readonly Dictionary<Binary, String> str8cache = new Dictionary<Binary, String>();

	protected abstract byte DoGet();

	protected abstract void DoGet(byte[] bytes);
	public abstract bool HasRemaining();

	protected byte Get()
	{
	return DoGet();
	}

	protected void Get(byte[] bytes)
	{
	DoGet(bytes);
	}

	protected Binary Get(int size)
	{
	byte[] bytes = new byte[size];
	Get(bytes);
	return new Binary(bytes);
	}

	protected short Uget()
	{
	return (short) (0xFF & Get());
	}

	public virtual short ReadUint8()
	{
	return Uget();
	}

	public abstract int ReadUint16();


	public abstract long ReadUint32();


	public int ReadSequenceNo()
	{
	return (int) ReadUint32();
	}

	public virtual long ReadUint64()
	{
	long l = 0;
	for (int i = 0; i < 8; i++)
	{
	l \|= ((long) (0xFF & Get())) << (56 - i*8);
	}
	return l;
	}

	public abstract short ReadInt8();
	public abstract int ReadInt16();
	public abstract long ReadInt32() ;
	public abstract long ReadInt64();
	public abstract float ReadFloat() ;
	public abstract double ReadDouble() ;

	public long ReadDatetime()
	{
	return ReadUint64();
	}

	private static String Decode(byte[] bytes, int offset, int length, Encoding encoding)
	{
	return encoding.GetString(bytes, offset, length);
	}

	private static String Decode(byte[] bytes, Encoding encoding)
	{
	return Decode(bytes, 0, bytes.Length, encoding);
	}

	public String ReadStr8()
	{
	short size = ReadUint8();
	Binary bin = Get(size);
	String str;
	if (! str8cache.TryGetValue(bin, out str))
	{
	str = Decode(bin.Array(), bin.Offset(), bin.Size(), Encoding.UTF8);
	str8cache.Add(bin, str);
	}
	return str;
	}

	public String ReadStr16()
	{
	int size = ReadUint16();
	byte[] bytes = new byte[size];
	Get(bytes);
	return Decode(bytes, Encoding.UTF8);
	}

	public byte[] ReadVbin8()
	{
	int size = ReadUint8();
	byte[] bytes = new byte[size];
	Get(bytes);
	return bytes;
	}

	public byte[] ReadVbin16()
	{
	int size = ReadUint16();
	byte[] bytes = new byte[size];
	Get(bytes);
	return bytes;
	}

	public byte[] ReadVbin32()
	{
	int size = (int) ReadUint32();
	byte[] bytes = new byte[size];
	Get(bytes);
	return bytes;
	}

	public RangeSet ReadSequenceSet()
	{
	int count = ReadUint16()/8;
	if (count == 0)
	{
	return null;
	}
	RangeSet ranges = new RangeSet();
	for (int i = 0; i < count; i++)
	{
	ranges.Add(ReadSequenceNo(), ReadSequenceNo());
	}
	return ranges;
	}

	public RangeSet ReadByteRanges()
	{
	throw new Exception("not implemented");
	}

	public UUID ReadUuid()
	{
	long msb = ReadUint64();
	long lsb = ReadUint64();
	return new UUID(msb, lsb);
	}

	public String ReadContent()
	{
	throw new Exception("Deprecated");
	}

	public Struct ReadStruct(int type)
	{
	Struct st = Struct.Create(type);
	int width = st.GetSizeWidth();
	if (width > 0)
	{
	long size = ReadSize(width);
	if (size == 0)
	{
	return null;
	}
	}
	if (type > 0)
	{
	int code = ReadUint16();
	Debug.Assert(code == type);
	}
	st.Read(this);
	return st;
	}

	public Struct ReadStruct32()
	{
	long size = ReadUint32();
	if (size == 0)
	{
	return null;
	}
	int type = ReadUint16();
	Struct result = Struct.Create(type);
	result.Read(this);
	return result;
	}

	public Dictionary<String, Object> ReadMap()
	{
	long size = ReadUint32();

	if (size == 0)
	{
	return null;
	}

	long count = ReadUint32();

	Dictionary<String, Object> result = new Dictionary<String, Object>();
	for (int i = 0; i < count; i++)
	{
	String key = ReadStr8();
	byte code = Get();
	QpidType t = GetType(code);
	Object value = Read(t);
	result.Add(key, value);
	}

	return result;
	}

	public List<Object> ReadList()
	{
	long size = ReadUint32();

	if (size == 0)
	{
	return null;
	}

	long count = ReadUint32();

	List<Object> result = new List<Object>();
	for (int i = 0; i < count; i++)
	{
	byte code = Get();
	QpidType t = GetType(code);
	Object value = Read(t);
	result.Add(value);
	}
	return result;
	}

	public List<Object> ReadArray()
	{
	long size = ReadUint32();

	if (size == 0)
	{
	return null;
	}

	byte code = Get();
	QpidType t = GetType(code);
	long count = ReadUint32();

	List<Object> result = new List<Object>();
	for (int i = 0; i < count; i++)
	{
	Object value = Read(t);
	result.Add(value);
	}
	return result;
	}

	private QpidType GetType(byte code)
	{
	return QpidType.get(code);
	}

	private long ReadSize(QpidType t)
	{
	return t.Fixed ? t.Width : ReadSize(t.Width);
	}

	private long ReadSize(int width)
	{
	switch (width)
	{
	case 1:
	return ReadUint8();
	case 2:
	return ReadUint16();
	case 4:
	return ReadUint32();
	default:
	throw new Exception("illegal width: " + width);
	}
	}

	private byte[] ReadBytes(QpidType t)
	{
	long size = ReadSize(t);
	byte[] result = new byte[(int) size];
	Get(result);
	return result;
	}

	private Object Read(QpidType t)
	{
	switch (t.Code)
	{
	case Code.BIN8:
	case Code.UINT8:
	return ReadUint8();
	case Code.INT8:
	return Get();
	case Code.CHAR:
	return (char) Get();
	case Code.BOOLEAN:
	return Get() > 0;

	case Code.BIN16:
	case Code.UINT16:
	return ReadUint16();
	case Code.INT16:
	return (short) ReadUint16();

	case Code.BIN32:
	case Code.UINT32:
	return ReadUint32();

	case Code.CHAR_UTF32:
	case Code.INT32:
	return (int) ReadUint32();

	case Code.FLOAT:
	return (float)BitConverter.Int64BitsToDouble(ReadUint32() << 32);

	case Code.BIN64:
	case Code.UINT64:
	case Code.INT64:
	case Code.DATETIME:
	return ReadUint64();

	case Code.DOUBLE:
	return BitConverter.Int64BitsToDouble(ReadUint64());
	case Code.UUID:
	return ReadUuid();
	case Code.STR8:
	return ReadStr8();
	case Code.STR16:
	return ReadStr16();
	case Code.STR8_LATIN:
	case Code.STR8_UTF16:
	case Code.STR16_LATIN:
	case Code.STR16_UTF16:
	// XXX: need to do character conversion
	return Encoding.UTF8.GetString(ReadBytes(t));

	case Code.MAP:
	return ReadMap();
	case Code.LIST:
	return ReadList();
	case Code.ARRAY:
	return ReadArray();
	case Code.STRUCT32:
	return ReadStruct32();

	case Code.BIN40:
	case Code.DEC32:
	case Code.BIN72:
	case Code.DEC64:
	// XXX: what types are we supposed to use here?
	return ReadBytes(t);

	case Code.VOID:
	return null;

	default:
	return ReadBytes(t);
	}
	}
	}
	}