src/NMS.AMQP/Util/Types/ConversionSupport.cs - activemq-nms-amqp - 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;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Amqp.Types;
 using Amqp;
 using Apache.NMS;

 namespace Apache.NMS.AMQP.Util.Types
 {
     internal static class ConversionSupport
     {
         public static Amqp.Types.Map NMSMapToAmqp(IPrimitiveMap nmsmap)
         {
             if(nmsmap == null) return null;
             Amqp.Types.Map result = new Amqp.Types.Map();
             if(nmsmap is Map.AMQP.AMQPValueMap) { return (nmsmap as Map.AMQP.AMQPValueMap).AmqpMap; }
             else
             {
                 foreach (string key in nmsmap.Keys)
                 {
                     object value = nmsmap[key];

                     if (value is IDictionary)
                     {
                         value = ConversionSupport.MapToAmqp(value as IDictionary);
                     }
                     else if (value is IList)
                     {
                         value = ConversionSupport.ListToAmqp(value as IList);
                     }

                     result[key] = value;
                     //Tracer.InfoFormat("Conversion key : {0}, value : {1}, valueType: {2} nmsValue: {3}, nmsValueType: {4}.",
                     //    key, value, value.GetType().Name, );
                 }
             }
             return result;
         }

         public static IPrimitiveMap AmqpMapToNMS(Amqp.Types.Map map)
         {
             if (map == null) return null;
             IPrimitiveMap result = new Map.AMQP.AMQPValueMap(map);
             return result;
         }

         public static Amqp.Types.Map MapToAmqp(IDictionary dictionary)
         {
             if (dictionary == null) return null;
             /*if (dictionary is Amqp.Types.Map)
             {
                 Amqp.Types.Map DictMap = dictionary as Amqp.Types.Map;

                 return DictMap.Clone() as Amqp.Types.Map;
             }*/
             Amqp.Types.Map map = new Amqp.Types.Map();
             IEnumerator iterator = dictionary.Keys.GetEnumerator();
             iterator.MoveNext();
             object key = iterator.Current;
             if (key == null) return null;
             object value = null;
             do
             {
                 value = dictionary[key];
                 if (value != null)
                 {
                     Type valtype = value.GetType();
                     if (value is IDictionary)
                     {
                         map[key] = ConversionSupport.MapToAmqp(value as IDictionary);
                     }
                     else if (value is IList)
                     {
                         map[key] = ConversionSupport.ListToAmqp(value as IList);
                     }
                     else if (IsNMSType(value))
                     //else if (valtype.IsPrimitive || value is byte[] || value is String)
                     {
                         map[key] = value;
                     }
                     else
                     {
                         Tracer.InfoFormat("Failed to convert IDictionary[{0}], value{1} to Map value: Invalid Type: {2}",
                             key, value.ToString(), valtype.Name);
                     }

                 }

             }
             while (iterator.MoveNext() && (key = iterator.Current) != null);
             return map;
         }


         public static IDictionary MapToNMS(Amqp.Types.Map map)
         {
             if (map == null) return null;

             IDictionary dictionary = new Dictionary<object, object>(map) as IDictionary;

             return dictionary;
         }

         public static IList ListToAmqp(IList ilist)
         {
             if (ilist == null) return null;
             //
             // Special case for Byte[] which has the iList interface, we
             // don't want to convert Byte[] to a List so just return a copy.
             // Return a copy because it may be added to a List or Dictionary as
             // a reference, which will arrive here, and we want to be sure we have
             // our own copy after return.
             if (ilist is Byte[])
             {
                 byte[] copy = new byte[(ilist as Byte[]).Length];
                 Array.Copy(ilist as Byte[], 0, copy, 0, (ilist as Byte[]).Length);
                 return copy;
             }
             List list = new List();
             foreach(object o in ilist)
             {
                 object value = o;
                 if(o != null)
                 {
                     Type valtype = value.GetType();
                     if (value is IDictionary)
                     {
                         value = ConversionSupport.MapToAmqp(value as IDictionary);
                     }
                     else if (value is IList)
                     {
                         value = ConversionSupport.ListToAmqp(value as IList);
                     }
                     else if (ConversionSupport.IsNMSType(value))
                     //else if (valtype.IsPrimitive || value is byte[] || value is String)
                     {
                         // do nothing
                         // value = value;
                     }
                     else
                     {
                         Tracer.InfoFormat("Failed to convert IList to amqp List value({0}): Invalid Type: {1}",
                             value.ToString(), valtype.Name);
                     }
                 }
                 list.Add(value);
             }
             return list;
         }

         public static IList ListToNMS(List list)
         {
             if (list == null) return null;
             IList ilist = new ArrayList(list);
             return ilist;
         }

         public static string ToString(Amqp.Types.Map map)
         {
             if (map == null) return "{}";
             string result = "{";
             bool first = true;
             foreach (object key in map.Keys)
             {
                 if (first) result += "\n";
                 first = false;
                 //
                 // handle byte arrays for now
                 // add more special handlers as needed.
                 //
                 if (map[key] is byte[])
                 {

                     result += string.Format("key: {0}, len={1}, {2};\n", key.ToString(), (map[key] as byte[]).Length, BitConverter.ToString(map[key] as byte[]).Replace("-", " "));
                 }
                 else
                 {
                     result += "key: " + key.ToString() + ", value: " + map[key].ToString() + ";\n";
                 }
             }
             result += "}";
             return result;
         }

         public static string ToString(IPrimitiveMap map)
         {
             if (map == null) return "{}";
             string result = "{";
             bool first = true;
             foreach (string key in map.Keys)
             {
                 if (first) result += "\n";
                 first = false;
                 if (map[key] is byte[])
                 {

                     result += string.Format("key: {0}, len={1}, value: {2};\n", key.ToString(), (map[key] as byte[]).Length, BitConverter.ToString(map[key] as byte[]).Replace("-", " "));
                 }
                 else
                 {
                     result += "key: " + key.ToString() + ", value: " + map[key].ToString() + ";\n";
                 }
             }
             result += "}";
             return result;
         }

         #region NMS Type Conversion Table

         static ConversionSupport(){
             Dictionary < ConversionKey, ConversionEntry > typeMap = new Dictionary<ConversionKey, ConversionEntry>(NMSTypeConversionSet.Count);
             foreach(ConversionEntry entry in NMSTypeConversionSet)
             {
                 typeMap.Add(entry, entry);
             }

             NMSTypeConversionTable = typeMap;
         }

         public enum NMS_TYPE_INDEX
         {
             STRING = 0,
             INT32 = 1,
             UINT32 = 2,
             INT16 = 3,
             UINT16 = 4,
             INT64 = 5,
             UINT64 = 6,
             FLOAT32 = 7,
             FLOAT64 = 8,
             DOUBLE = 8,
             INT8 = 9,
             UINT8 = 10,
             CHAR = 11,
             BOOLEAN = 12,
             BYTE_ARRAY = 13,
             NULL = 14,
             OBJECT = 15,
             UNKOWN
         }

         private static readonly Type[] NMSTypes = { typeof(String),
             typeof(int), typeof(uint),
             typeof(short), typeof(ushort),
             typeof(long), typeof(ulong),
             typeof(float), typeof(double),
             typeof(sbyte), typeof(byte),
             typeof(char), typeof(bool), typeof(byte[]), null, typeof(object) };

         public delegate T ConversionInstance<T, K>(K o);

         private class ConversionKey : IComparable
         {
             private int hash = 0;
             internal static ConversionKey GetKey(Type target, Type Source)
             {

                 return new ConversionKey(target, Source);
             }
             protected ConversionKey(Type target, Type source)
             {
                 TargetType = target;
                 SourceType = source;
                 SetHashCode();
             }
             public Type TargetType { get; protected set; }
             public Type SourceType { get; protected set; }

             public int CompareTo(object obj)
             {
                 if(obj != null && obj is ConversionKey) { return CompareTo(obj as ConversionKey); }
                 return -1;
             }

             protected void SetHashCode()
             {
                 long th = TargetType.GetHashCode();
                 long sh = SourceType.GetHashCode();
                 // Cantor pairing
                 hash = (int)((th + sh) * (th + sh + 1) / 2 + sh);
             }

             protected virtual int CompareTo(ConversionKey other)
             {
                 return other.GetHashCode() - this.GetHashCode();
             }

             public override bool Equals(object obj)
             {
                 if(obj != null && obj is ConversionKey)
                 {
                     return this.CompareTo(obj as ConversionKey) == 0;
                 }
                 else
                 {
                     return base.Equals(obj);
                 }
             }

             public override int GetHashCode()
             {
                 return hash;
             }

             public override string ToString()
             {
                 return this.GetType().Name + "| SourceType: " + SourceType.Name + ", TargetType " + TargetType.Name;
             }
         }

         private abstract class ConversionEntry : ConversionKey
         {

             protected ConversionEntry(Type t, Type s) : base(t,s) { }

             public abstract object Convert(object o);
         }

         private class ConversionEntry<T, K> : ConversionEntry
         {
             internal ConversionInstance<T, K> ConvertInstance;

             internal ConversionEntry() : base(typeof(T), typeof(K))
             {
             }


             public override object Convert(object o)
             {
                 if (ConvertInstance != null)
                 {
                     return ConvertInstance((K)o);
                 }
                 return null;
             }

             public override string ToString()
             {
                 return base.ToString() + ", Convert Instance Delegate : " + ConvertInstance.ToString();
             }
         }

         //public static readonly IReadOnlyDictionary<Type, IReadOnlyDictionary<Type, ConversionInstance<,object>>> NMSTypeConversionTable = new Dictionary<Type, IReadOnlyDictionary<Type, ConversionInstance<?,?>>>
         //{
         /* Type convert to                           Types convert from            */
         /*{ Types[Convert.ToInt32(TYPE_INDEX.STRING)], new Type[]{ typeof(string), typeof(float), typeof(double), typeof(long), typeof(int),typeof(short),typeof(byte),typeof(bool),typeof(char)} },
         { Types[Convert.ToInt32(TYPE_INDEX.DOUBLE)], new Type[]{ typeof(string), typeof(float), typeof(double)} },
         { Types[Convert.ToInt32(TYPE_INDEX.FLOAT32)], new Type[]{ typeof(string), typeof(float)} },
         { Types[Convert.ToInt32(TYPE_INDEX.INT64)], new Type[]{ typeof(string), typeof(long), typeof(int), typeof(short), typeof(byte)} },
         { Types[Convert.ToInt32(TYPE_INDEX.INT32)], new Type[]{ typeof(string), typeof(int), typeof(short), typeof(byte)} },
         { Types[Convert.ToInt32(TYPE_INDEX.INT16)], new Type[]{ typeof(string), typeof(short), typeof(byte)} },
         { Types[Convert.ToInt32(TYPE_INDEX.INT8)], new Type[]{ typeof(string), typeof(byte)} },
         { Types[Convert.ToInt32(TYPE_INDEX.CHAR)], new Type[]{ typeof(char)} },
         { Types[Convert.ToInt32(TYPE_INDEX.BOOLEAN)], new Type[]{ typeof(string), typeof(bool)} },*/

         //};
 #if NET40
         private static readonly IDictionary<ConversionKey, ConversionEntry> NMSTypeConversionTable;
 #else

         private static readonly IReadOnlyDictionary<ConversionKey, ConversionEntry> NMSTypeConversionTable;
 #endif
         private static readonly ISet<ConversionEntry> NMSTypeConversionSet = new HashSet<ConversionEntry>
         {
             // string conversion
             { new ConversionEntry<string, string>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, float>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, double>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, long>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, int>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, short>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, bool>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, char>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, ulong>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, uint>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, ushort>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             { new ConversionEntry<string, byte>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
             //{new ConversionEntry<string, byte[]>{ConvertInstance = ((o) =>{ throw new InvalidOperationException("Cannot convert string to byte array."); }) } },
             // double conversion
             { new ConversionEntry<double, string>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
             { new ConversionEntry<double, float>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
             { new ConversionEntry<double, double>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
             // float conversion
             { new ConversionEntry<float, string>{ConvertInstance = ((o) =>{ return Convert.ToSingle(o); }) } },
             { new ConversionEntry<float, float>{ConvertInstance = ((o) =>{ return Convert.ToSingle(o); }) } },
             // long conversion
             { new ConversionEntry<long, string>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, long>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, int>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, short>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, ulong>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, uint>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             { new ConversionEntry<long, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
             // int conversion
             { new ConversionEntry<int, string>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, int>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, short>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, uint>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             { new ConversionEntry<int, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
             // short conversion
             { new ConversionEntry<short, string>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
             { new ConversionEntry<short, short>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
             { new ConversionEntry<short, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
             { new ConversionEntry<short, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
             { new ConversionEntry<short, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
             // sbyte conversion
             { new ConversionEntry<sbyte, string>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
             { new ConversionEntry<sbyte, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
             { new ConversionEntry<sbyte, byte>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
             // ulong conversion
             { new ConversionEntry<ulong, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, long>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, int>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, ulong>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, uint>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             { new ConversionEntry<ulong, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
             // uint conversion
             { new ConversionEntry<uint, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, int>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, uint>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             { new ConversionEntry<uint, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
             // ushort conversion
             { new ConversionEntry<ushort, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
             { new ConversionEntry<ushort, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
             { new ConversionEntry<ushort, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
             { new ConversionEntry<ushort, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
             { new ConversionEntry<ushort, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
             // byte conversion
             { new ConversionEntry<byte, string>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
             { new ConversionEntry<byte, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
             { new ConversionEntry<byte, byte>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
             // boolean conversion
             { new ConversionEntry<bool, string>{ConvertInstance = ((o) =>{ return Convert.ToBoolean(o); }) } },
             { new ConversionEntry<bool, bool>{ConvertInstance = ((o) =>{ return Convert.ToBoolean(o); }) } },
             // char conversion
             { new ConversionEntry<char, char>{ConvertInstance = ((o) =>{ return Convert.ToChar(o); }) } },
         };


         public static Type ForIndex(NMS_TYPE_INDEX index)
         {
             int i = Convert.ToInt32(index);

             if(i<0 || i >= (int)NMS_TYPE_INDEX.UNKOWN)
             {
                 throw new IndexOutOfRangeException("Unrecognized NMS Type Index " + index);
             }
             else
             {
                 return NMSTypes[i];
             }

         }

         public static bool IsNMSType(object value)
         {
             bool result = false;
             int index = 0;
             Type t = NMSTypes[index];
             while (t != null && !result)
             {
                 result = t.Equals(value.GetType());
                 t = NMSTypes[++index];
             }
             return result;
         }

         public static bool CanConvertNMSType<T>(object value)
         {
             ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
             return NMSTypeConversionSet.Contains(key);
         }

         public static T ConvertNMSType<T, S>(S value)
         {
             ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
             ConversionEntry<T, S> converter = (ConversionEntry<T, S>)NMSTypeConversionTable[key];
             if(converter == null)
             {
                 throw new NMSTypeConversionException("Cannot convert between type : " + (typeof(T)).Name + ", and type: " + value.GetType().Name);
             }
             return converter.ConvertInstance(value);

         }

         public static T ConvertNMSType<T>(object value)
         {
             ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
             NMSTypeConversionTable.TryGetValue(key, out ConversionEntry converter);
             if (converter == null)
             {
                 throw new NMSTypeConversionException("Cannot convert between type : " + (typeof(T)).Name + ", and type: " + value.GetType().Name);
             }
             return (T)converter.Convert(value);
         }

         public class NMSTypeConversionException : MessageFormatException
         {
             public NMSTypeConversionException() : base() { }
             public NMSTypeConversionException(string message) : base(message) { }
         }

 #endregion

     }
 }
	/*
	* 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;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;
	using Amqp.Types;
	using Amqp;
	using Apache.NMS;

	namespace Apache.NMS.AMQP.Util.Types
	{
	internal static class ConversionSupport
	{
	public static Amqp.Types.Map NMSMapToAmqp(IPrimitiveMap nmsmap)
	{
	if(nmsmap == null) return null;
	Amqp.Types.Map result = new Amqp.Types.Map();
	if(nmsmap is Map.AMQP.AMQPValueMap) { return (nmsmap as Map.AMQP.AMQPValueMap).AmqpMap; }
	else
	{
	foreach (string key in nmsmap.Keys)
	{
	object value = nmsmap[key];

	if (value is IDictionary)
	{
	value = ConversionSupport.MapToAmqp(value as IDictionary);
	}
	else if (value is IList)
	{
	value = ConversionSupport.ListToAmqp(value as IList);
	}

	result[key] = value;
	//Tracer.InfoFormat("Conversion key : {0}, value : {1}, valueType: {2} nmsValue: {3}, nmsValueType: {4}.",
	// key, value, value.GetType().Name, );
	}
	}
	return result;
	}

	public static IPrimitiveMap AmqpMapToNMS(Amqp.Types.Map map)
	{
	if (map == null) return null;
	IPrimitiveMap result = new Map.AMQP.AMQPValueMap(map);
	return result;
	}

	public static Amqp.Types.Map MapToAmqp(IDictionary dictionary)
	{
	if (dictionary == null) return null;
	/*if (dictionary is Amqp.Types.Map)
	{
	Amqp.Types.Map DictMap = dictionary as Amqp.Types.Map;

	return DictMap.Clone() as Amqp.Types.Map;
	}*/
	Amqp.Types.Map map = new Amqp.Types.Map();
	IEnumerator iterator = dictionary.Keys.GetEnumerator();
	iterator.MoveNext();
	object key = iterator.Current;
	if (key == null) return null;
	object value = null;
	do
	{
	value = dictionary[key];
	if (value != null)
	{
	Type valtype = value.GetType();
	if (value is IDictionary)
	{
	map[key] = ConversionSupport.MapToAmqp(value as IDictionary);
	}
	else if (value is IList)
	{
	map[key] = ConversionSupport.ListToAmqp(value as IList);
	}
	else if (IsNMSType(value))
	//else if (valtype.IsPrimitive \|\| value is byte[] \|\| value is String)
	{
	map[key] = value;
	}
	else
	{
	Tracer.InfoFormat("Failed to convert IDictionary[{0}], value{1} to Map value: Invalid Type: {2}",
	key, value.ToString(), valtype.Name);
	}

	}

	}
	while (iterator.MoveNext() && (key = iterator.Current) != null);
	return map;
	}


	public static IDictionary MapToNMS(Amqp.Types.Map map)
	{
	if (map == null) return null;

	IDictionary dictionary = new Dictionary<object, object>(map) as IDictionary;

	return dictionary;
	}

	public static IList ListToAmqp(IList ilist)
	{
	if (ilist == null) return null;
	//
	// Special case for Byte[] which has the iList interface, we
	// don't want to convert Byte[] to a List so just return a copy.
	// Return a copy because it may be added to a List or Dictionary as
	// a reference, which will arrive here, and we want to be sure we have
	// our own copy after return.
	if (ilist is Byte[])
	{
	byte[] copy = new byte[(ilist as Byte[]).Length];
	Array.Copy(ilist as Byte[], 0, copy, 0, (ilist as Byte[]).Length);
	return copy;
	}
	List list = new List();
	foreach(object o in ilist)
	{
	object value = o;
	if(o != null)
	{
	Type valtype = value.GetType();
	if (value is IDictionary)
	{
	value = ConversionSupport.MapToAmqp(value as IDictionary);
	}
	else if (value is IList)
	{
	value = ConversionSupport.ListToAmqp(value as IList);
	}
	else if (ConversionSupport.IsNMSType(value))
	//else if (valtype.IsPrimitive \|\| value is byte[] \|\| value is String)
	{
	// do nothing
	// value = value;
	}
	else
	{
	Tracer.InfoFormat("Failed to convert IList to amqp List value({0}): Invalid Type: {1}",
	value.ToString(), valtype.Name);
	}
	}
	list.Add(value);
	}
	return list;
	}

	public static IList ListToNMS(List list)
	{
	if (list == null) return null;
	IList ilist = new ArrayList(list);
	return ilist;
	}

	public static string ToString(Amqp.Types.Map map)
	{
	if (map == null) return "{}";
	string result = "{";
	bool first = true;
	foreach (object key in map.Keys)
	{
	if (first) result += "\n";
	first = false;
	//
	// handle byte arrays for now
	// add more special handlers as needed.
	//
	if (map[key] is byte[])
	{

	result += string.Format("key: {0}, len={1}, {2};\n", key.ToString(), (map[key] as byte[]).Length, BitConverter.ToString(map[key] as byte[]).Replace("-", " "));
	}
	else
	{
	result += "key: " + key.ToString() + ", value: " + map[key].ToString() + ";\n";
	}
	}
	result += "}";
	return result;
	}

	public static string ToString(IPrimitiveMap map)
	{
	if (map == null) return "{}";
	string result = "{";
	bool first = true;
	foreach (string key in map.Keys)
	{
	if (first) result += "\n";
	first = false;
	if (map[key] is byte[])
	{

	result += string.Format("key: {0}, len={1}, value: {2};\n", key.ToString(), (map[key] as byte[]).Length, BitConverter.ToString(map[key] as byte[]).Replace("-", " "));
	}
	else
	{
	result += "key: " + key.ToString() + ", value: " + map[key].ToString() + ";\n";
	}
	}
	result += "}";
	return result;
	}

	#region NMS Type Conversion Table

	static ConversionSupport(){
	Dictionary < ConversionKey, ConversionEntry > typeMap = new Dictionary<ConversionKey, ConversionEntry>(NMSTypeConversionSet.Count);
	foreach(ConversionEntry entry in NMSTypeConversionSet)
	{
	typeMap.Add(entry, entry);
	}

	NMSTypeConversionTable = typeMap;
	}

	public enum NMS_TYPE_INDEX
	{
	STRING = 0,
	INT32 = 1,
	UINT32 = 2,
	INT16 = 3,
	UINT16 = 4,
	INT64 = 5,
	UINT64 = 6,
	FLOAT32 = 7,
	FLOAT64 = 8,
	DOUBLE = 8,
	INT8 = 9,
	UINT8 = 10,
	CHAR = 11,
	BOOLEAN = 12,
	BYTE_ARRAY = 13,
	NULL = 14,
	OBJECT = 15,
	UNKOWN
	}

	private static readonly Type[] NMSTypes = { typeof(String),
	typeof(int), typeof(uint),
	typeof(short), typeof(ushort),
	typeof(long), typeof(ulong),
	typeof(float), typeof(double),
	typeof(sbyte), typeof(byte),
	typeof(char), typeof(bool), typeof(byte[]), null, typeof(object) };

	public delegate T ConversionInstance<T, K>(K o);

	private class ConversionKey : IComparable
	{
	private int hash = 0;
	internal static ConversionKey GetKey(Type target, Type Source)
	{

	return new ConversionKey(target, Source);
	}
	protected ConversionKey(Type target, Type source)
	{
	TargetType = target;
	SourceType = source;
	SetHashCode();
	}
	public Type TargetType { get; protected set; }
	public Type SourceType { get; protected set; }

	public int CompareTo(object obj)
	{
	if(obj != null && obj is ConversionKey) { return CompareTo(obj as ConversionKey); }
	return -1;
	}

	protected void SetHashCode()
	{
	long th = TargetType.GetHashCode();
	long sh = SourceType.GetHashCode();
	// Cantor pairing
	hash = (int)((th + sh) * (th + sh + 1) / 2 + sh);
	}

	protected virtual int CompareTo(ConversionKey other)
	{
	return other.GetHashCode() - this.GetHashCode();
	}

	public override bool Equals(object obj)
	{
	if(obj != null && obj is ConversionKey)
	{
	return this.CompareTo(obj as ConversionKey) == 0;
	}
	else
	{
	return base.Equals(obj);
	}
	}

	public override int GetHashCode()
	{
	return hash;
	}

	public override string ToString()
	{
	return this.GetType().Name + "\| SourceType: " + SourceType.Name + ", TargetType " + TargetType.Name;
	}
	}

	private abstract class ConversionEntry : ConversionKey
	{

	protected ConversionEntry(Type t, Type s) : base(t,s) { }

	public abstract object Convert(object o);
	}

	private class ConversionEntry<T, K> : ConversionEntry
	{
	internal ConversionInstance<T, K> ConvertInstance;

	internal ConversionEntry() : base(typeof(T), typeof(K))
	{
	}


	public override object Convert(object o)
	{
	if (ConvertInstance != null)
	{
	return ConvertInstance((K)o);
	}
	return null;
	}

	public override string ToString()
	{
	return base.ToString() + ", Convert Instance Delegate : " + ConvertInstance.ToString();
	}
	}

	//public static readonly IReadOnlyDictionary<Type, IReadOnlyDictionary<Type, ConversionInstance<,object>>> NMSTypeConversionTable = new Dictionary<Type, IReadOnlyDictionary<Type, ConversionInstance<?,?>>>
	//{
	/* Type convert to Types convert from */
	/*{ Types[Convert.ToInt32(TYPE_INDEX.STRING)], new Type[]{ typeof(string), typeof(float), typeof(double), typeof(long), typeof(int),typeof(short),typeof(byte),typeof(bool),typeof(char)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.DOUBLE)], new Type[]{ typeof(string), typeof(float), typeof(double)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.FLOAT32)], new Type[]{ typeof(string), typeof(float)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.INT64)], new Type[]{ typeof(string), typeof(long), typeof(int), typeof(short), typeof(byte)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.INT32)], new Type[]{ typeof(string), typeof(int), typeof(short), typeof(byte)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.INT16)], new Type[]{ typeof(string), typeof(short), typeof(byte)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.INT8)], new Type[]{ typeof(string), typeof(byte)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.CHAR)], new Type[]{ typeof(char)} },
	{ Types[Convert.ToInt32(TYPE_INDEX.BOOLEAN)], new Type[]{ typeof(string), typeof(bool)} },*/

	//};
	#if NET40
	private static readonly IDictionary<ConversionKey, ConversionEntry> NMSTypeConversionTable;
	#else

	private static readonly IReadOnlyDictionary<ConversionKey, ConversionEntry> NMSTypeConversionTable;
	#endif
	private static readonly ISet<ConversionEntry> NMSTypeConversionSet = new HashSet<ConversionEntry>
	{
	// string conversion
	{ new ConversionEntry<string, string>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, float>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, double>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, long>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, int>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, short>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, bool>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, char>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, ulong>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, uint>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, ushort>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	{ new ConversionEntry<string, byte>{ConvertInstance = ((o) =>{ return Convert.ToString(o); }) } },
	//{new ConversionEntry<string, byte[]>{ConvertInstance = ((o) =>{ throw new InvalidOperationException("Cannot convert string to byte array."); }) } },
	// double conversion
	{ new ConversionEntry<double, string>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
	{ new ConversionEntry<double, float>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
	{ new ConversionEntry<double, double>{ConvertInstance = ((o) =>{ return Convert.ToDouble(o); }) } },
	// float conversion
	{ new ConversionEntry<float, string>{ConvertInstance = ((o) =>{ return Convert.ToSingle(o); }) } },
	{ new ConversionEntry<float, float>{ConvertInstance = ((o) =>{ return Convert.ToSingle(o); }) } },
	// long conversion
	{ new ConversionEntry<long, string>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, long>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, int>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, short>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, ulong>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, uint>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	{ new ConversionEntry<long, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt64(o); }) } },
	// int conversion
	{ new ConversionEntry<int, string>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, int>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, short>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, uint>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	{ new ConversionEntry<int, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt32(o); }) } },
	// short conversion
	{ new ConversionEntry<short, string>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
	{ new ConversionEntry<short, short>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
	{ new ConversionEntry<short, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
	{ new ConversionEntry<short, ushort>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
	{ new ConversionEntry<short, byte>{ConvertInstance = ((o) =>{ return Convert.ToInt16(o); }) } },
	// sbyte conversion
	{ new ConversionEntry<sbyte, string>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
	{ new ConversionEntry<sbyte, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
	{ new ConversionEntry<sbyte, byte>{ConvertInstance = ((o) =>{ return Convert.ToSByte(o); }) } },
	// ulong conversion
	{ new ConversionEntry<ulong, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, long>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, int>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, ulong>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, uint>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	{ new ConversionEntry<ulong, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt64(o); }) } },
	// uint conversion
	{ new ConversionEntry<uint, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, int>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, uint>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	{ new ConversionEntry<uint, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt32(o); }) } },
	// ushort conversion
	{ new ConversionEntry<ushort, string>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
	{ new ConversionEntry<ushort, short>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
	{ new ConversionEntry<ushort, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
	{ new ConversionEntry<ushort, ushort>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
	{ new ConversionEntry<ushort, byte>{ConvertInstance = ((o) =>{ return Convert.ToUInt16(o); }) } },
	// byte conversion
	{ new ConversionEntry<byte, string>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
	{ new ConversionEntry<byte, sbyte>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
	{ new ConversionEntry<byte, byte>{ConvertInstance = ((o) =>{ return Convert.ToByte(o); }) } },
	// boolean conversion
	{ new ConversionEntry<bool, string>{ConvertInstance = ((o) =>{ return Convert.ToBoolean(o); }) } },
	{ new ConversionEntry<bool, bool>{ConvertInstance = ((o) =>{ return Convert.ToBoolean(o); }) } },
	// char conversion
	{ new ConversionEntry<char, char>{ConvertInstance = ((o) =>{ return Convert.ToChar(o); }) } },
	};


	public static Type ForIndex(NMS_TYPE_INDEX index)
	{
	int i = Convert.ToInt32(index);

	if(i<0 \|\| i >= (int)NMS_TYPE_INDEX.UNKOWN)
	{
	throw new IndexOutOfRangeException("Unrecognized NMS Type Index " + index);
	}
	else
	{
	return NMSTypes[i];
	}

	}

	public static bool IsNMSType(object value)
	{
	bool result = false;
	int index = 0;
	Type t = NMSTypes[index];
	while (t != null && !result)
	{
	result = t.Equals(value.GetType());
	t = NMSTypes[++index];
	}
	return result;
	}

	public static bool CanConvertNMSType<T>(object value)
	{
	ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
	return NMSTypeConversionSet.Contains(key);
	}

	public static T ConvertNMSType<T, S>(S value)
	{
	ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
	ConversionEntry<T, S> converter = (ConversionEntry<T, S>)NMSTypeConversionTable[key];
	if(converter == null)
	{
	throw new NMSTypeConversionException("Cannot convert between type : " + (typeof(T)).Name + ", and type: " + value.GetType().Name);
	}
	return converter.ConvertInstance(value);

	}

	public static T ConvertNMSType<T>(object value)
	{
	ConversionKey key = ConversionKey.GetKey(typeof(T), value.GetType());
	NMSTypeConversionTable.TryGetValue(key, out ConversionEntry converter);
	if (converter == null)
	{
	throw new NMSTypeConversionException("Cannot convert between type : " + (typeof(T)).Name + ", and type: " + value.GetType().Name);
	}
	return (T)converter.Convert(value);
	}

	public class NMSTypeConversionException : MessageFormatException
	{
	public NMSTypeConversionException() : base() { }
	public NMSTypeConversionException(string message) : base(message) { }
	}

	#endregion

	}
	}