src/nms-api/Util/PrimitiveMap.cs - activemq-nms-api - 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.IO;

 namespace Apache.NMS.Util
 {
 	/// <summary>
 	/// A default implementation of IPrimitiveMap
 	/// </summary>
 	public class PrimitiveMap : IPrimitiveMap
 	{
 		public const byte NULL = 0;
 		public const byte BOOLEAN_TYPE = 1;
 		public const byte BYTE_TYPE = 2;
 		public const byte CHAR_TYPE = 3;
 		public const byte SHORT_TYPE = 4;
 		public const byte INTEGER_TYPE = 5;
 		public const byte LONG_TYPE = 6;
 		public const byte DOUBLE_TYPE = 7;
 		public const byte FLOAT_TYPE = 8;
 		public const byte STRING_TYPE = 9;
 		public const byte BYTE_ARRAY_TYPE = 10;
 		public const byte MAP_TYPE = 11;
 		public const byte LIST_TYPE = 12;
 		public const byte BIG_STRING_TYPE = 13;

 		private IDictionary dictionary = Hashtable.Synchronized(new Hashtable());

 		public void Clear()
 		{
 			dictionary.Clear();
 		}

 		public bool Contains(Object key)
 		{
 			return dictionary.Contains(key);
 		}

 		public void Remove(Object key)
 		{
 			dictionary.Remove(key);
 		}

 		public int Count
 		{
 			get { return dictionary.Count; }
 		}

 		public ICollection Keys
 		{
 			get { lock(dictionary.SyncRoot) return new ArrayList(dictionary.Keys); }
 		}

 		public ICollection Values
 		{
 			get { lock(dictionary.SyncRoot) return new ArrayList(dictionary.Values); }
 		}

 		public object this[string key]
 		{
 			get { return GetValue(key); }
 			set
 			{
 				CheckValidType(value);
 				SetValue(key, value);
 			}
 		}

 		public string GetString(string key)
 		{
 			Object value = GetValue(key);
 			if(value == null)
 			{
 				return null;
 			}
 			CheckValueType(value, typeof(string));
 			return (string) value;
 		}

 		public void SetString(string key, string value)
 		{
 			SetValue(key, value);
 		}

 		public bool GetBool(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(bool));
 			return (bool) value;
 		}

 		public void SetBool(String key, bool value)
 		{
 			SetValue(key, value);
 		}

 		public byte GetByte(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(byte));
 			return (byte) value;
 		}

 		public void SetByte(String key, byte value)
 		{
 			SetValue(key, value);
 		}

 		public char GetChar(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(char));
 			return (char) value;
 		}

 		public void SetChar(String key, char value)
 		{
 			SetValue(key, value);
 		}

 		public short GetShort(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(short));
 			return (short) value;
 		}

 		public void SetShort(String key, short value)
 		{
 			SetValue(key, value);
 		}

 		public int GetInt(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(int));
 			return (int) value;
 		}

 		public void SetInt(String key, int value)
 		{
 			SetValue(key, value);
 		}

 		public long GetLong(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(long));
 			return (long) value;
 		}

 		public void SetLong(String key, long value)
 		{
 			SetValue(key, value);
 		}

 		public float GetFloat(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(float));
 			return (float) value;
 		}

 		public void SetFloat(String key, float value)
 		{
 			SetValue(key, value);
 		}

 		public double GetDouble(String key)
 		{
 			Object value = GetValue(key);
 			CheckValueType(value, typeof(double));
 			return (double) value;
 		}

 		public void SetDouble(String key, double value)
 		{
 			SetValue(key, value);
 		}

 		public IList GetList(String key)
 		{
 			Object value = GetValue(key);
 			if(value != null && !(value is IList))
 			{
 				throw new NMSException("Property: " + key + " is not an IList but is: " + value);
 			}
 			return (IList) value;
 		}

 		public void SetList(String key, IList value)
 		{
 			SetValue(key, value);
 		}

 		public void SetBytes(String key, byte[] value)
 		{
 			this.SetBytes(key, value, 0, value.Length);
 		}

 		public void SetBytes(String key, byte[] value, int offset, int length)
 		{
 			byte[] copy = new byte[length];
 			Array.Copy(value, offset, copy, 0, length);
 			SetValue(key, copy);
 		}

 		public byte[] GetBytes(string key)
 		{
 			Object value = GetValue(key);
 			if(value != null && !(value is Byte[]))
 			{
 				throw new NMSException("Property: " + key + " is not an byte[] but is: " + value);
 			}
 			return (byte[]) value;
 		}

 		public IDictionary GetDictionary(String key)
 		{
 			Object value = GetValue(key);
 			if(value != null && !(value is IDictionary))
 			{
 				throw new NMSException("Property: " + key + " is not an IDictionary but is: " + value);
 			}
 			return (IDictionary) value;
 		}

 		public void SetDictionary(String key, IDictionary value)
 		{
 			SetValue(key, value);
 		}

 		protected virtual void SetValue(String key, Object value)
 		{
 			dictionary[key] = value;
 		}

 		protected virtual Object GetValue(String key)
 		{
 			return dictionary[key];
 		}

 		protected virtual void CheckValueType(Object value, Type type)
 		{
 			if(!type.IsInstanceOfType(value))
 			{
 				throw new NMSException("Expected type: " + type.Name + " but was: " + value);
 			}
 		}

 		protected virtual void CheckValidType(Object value)
 		{
 			if(value != null && !(value is IList) && !(value is IDictionary))
 			{
 				Type type = value.GetType();

 				if(type.IsInstanceOfType(typeof(Object)) ||
                    (!type.IsPrimitive && !type.IsValueType && !type.IsAssignableFrom(typeof(string))))
 				{
 					throw new NMSException("Invalid type: " + type.Name + " for value: " + value);
 				}
 			}
 		}

 		/// <summary>
 		/// Method ToString
 		/// </summary>
 		/// <returns>A string</returns>
 		public override String ToString()
 		{
 			String s = "{";
 			bool first = true;
 			lock(dictionary.SyncRoot)
 			{
 				foreach(DictionaryEntry entry in dictionary)
 				{
 					if(!first)
 					{
 						s += ", ";
 					}
 					first = false;
 					String name = (String) entry.Key;
 					Object value = entry.Value;
 					s += name + "=" + value;
 				}
 			}
 			s += "}";
 			return s;
 		}

 		/// <summary>
 		/// Unmarshalls the map from the given data or if the data is null just
 		/// return an empty map
 		/// </summary>
 		public static PrimitiveMap Unmarshal(byte[] data)
 		{
 			PrimitiveMap answer = new PrimitiveMap();
 			answer.dictionary = UnmarshalPrimitiveMap(data);
 			return answer;
 		}

 		/// <summary>
 		/// Unmarshals a PrimitiveMap directly from a Stream object.  This
 		/// allows for clients to read PrimitiveMaps from Compressed or other
 		/// wise encoded streams without this class needing to know about it.
 		/// </summary>
 		/// <param name="source">
 		/// A <see cref="Stream"/>
 		/// </param>
 		/// <returns>
 		/// A <see cref="PrimitiveMap"/>
 		/// </returns>
 		public static PrimitiveMap Unmarshal(Stream source)
 		{
 			PrimitiveMap answer = new PrimitiveMap();
 			answer.dictionary = UnmarshalPrimitiveMap(source);
 			return answer;
 		}

 		public byte[] Marshal()
 		{
 			lock(dictionary.SyncRoot)
 			{
 				return MarshalPrimitiveMap(dictionary);
 			}
 		}

 		/// <summary>
 		/// Marshals a PrimitiveMap directly to a Stream object.  This
 		/// allows a client to write a PrimitiveMap in a compressed or
 		/// otherwise encoded form without this class needing to know
 		/// about it.
 		/// </summary>
 		/// <param name="destination">
 		/// A <see cref="Stream"/>
 		/// </param>
 		public void Marshal(Stream destination)
 		{
 			lock(dictionary.SyncRoot)
 			{
 				MarshalPrimitiveMap(dictionary, destination);
 			}
 		}

 		/// <summary>
 		/// Marshals the primitive type map to a byte array
 		/// </summary>
 		public static byte[] MarshalPrimitiveMap(IDictionary map)
 		{
 			if(map == null)
 			{
 				return null;
 			}

 			MemoryStream memoryStream = new MemoryStream();
 			lock(map.SyncRoot)
 			{
 				MarshalPrimitiveMap(map, new EndianBinaryWriter(memoryStream));
 			}

 			return memoryStream.ToArray();
 		}

 		public static void MarshalPrimitiveMap(IDictionary map, Stream stream)
 		{
 			if(map != null)
 			{
 				lock(map.SyncRoot)
 				{
 					MarshalPrimitiveMap(map, new EndianBinaryWriter(stream));
 				}
 			}
 		}

 		public static void MarshalPrimitiveMap(IDictionary map, BinaryWriter dataOut)
 		{
 			if(map == null)
 			{
 				dataOut.Write((int) -1);
 			}
 			else
 			{
 				lock(map.SyncRoot)
 				{
 					dataOut.Write(map.Count);
 					foreach(DictionaryEntry entry in map)
 					{
 						String name = (String) entry.Key;
 						dataOut.Write(name);
 						Object value = entry.Value;
 						MarshalPrimitive(dataOut, value);
 					}
 				}
 			}
 		}

 		/// <summary>
 		/// Unmarshals the primitive type map from the given byte array
 		/// </summary>
 		public static IDictionary UnmarshalPrimitiveMap(byte[] data)
 		{
 			if(data == null)
 			{
 				return new Hashtable();
 			}
 			else
 			{
 				return UnmarshalPrimitiveMap(new EndianBinaryReader(new MemoryStream(data)));
 			}
 		}

 		public static IDictionary UnmarshalPrimitiveMap(Stream source)
 		{
 			return UnmarshalPrimitiveMap(new EndianBinaryReader(source));
 		}

 		public static IDictionary UnmarshalPrimitiveMap(BinaryReader dataIn)
 		{
 			int size = dataIn.ReadInt32();
 			if(size < 0)
 			{
 				return null;
 			}

 			IDictionary answer = new Hashtable(size);
 			for(int i = 0; i < size; i++)
 			{
 				String name = dataIn.ReadString();
 				answer[name] = UnmarshalPrimitive(dataIn);
 			}

 			return answer;
 		}

 		public static void MarshalPrimitiveList(IList list, BinaryWriter dataOut)
 		{
 			dataOut.Write((int) list.Count);
 			foreach(Object element in list)
 			{
 				MarshalPrimitive(dataOut, element);
 			}
 		}

 		public static IList UnmarshalPrimitiveList(BinaryReader dataIn)
 		{
 			int size = dataIn.ReadInt32();
 			IList answer = new ArrayList(size);
 			while(size-- > 0)
 			{
 				answer.Add(UnmarshalPrimitive(dataIn));
 			}

 			return answer;
 		}

 		public static void MarshalPrimitive(BinaryWriter dataOut, Object value)
 		{
 			if(value == null)
 			{
 				dataOut.Write(NULL);
 			}
 			else if(value is bool)
 			{
 				dataOut.Write(BOOLEAN_TYPE);
 				dataOut.Write((bool) value);
 			}
 			else if(value is byte)
 			{
 				dataOut.Write(BYTE_TYPE);
 				dataOut.Write(((byte) value));
 			}
 			else if(value is char)
 			{
 				dataOut.Write(CHAR_TYPE);
 				dataOut.Write((char) value);
 			}
 			else if(value is short)
 			{
 				dataOut.Write(SHORT_TYPE);
 				dataOut.Write((short) value);
 			}
 			else if(value is int)
 			{
 				dataOut.Write(INTEGER_TYPE);
 				dataOut.Write((int) value);
 			}
 			else if(value is long)
 			{
 				dataOut.Write(LONG_TYPE);
 				dataOut.Write((long) value);
 			}
 			else if(value is float)
 			{
 				dataOut.Write(FLOAT_TYPE);
 				dataOut.Write((float) value);
 			}
 			else if(value is double)
 			{
 				dataOut.Write(DOUBLE_TYPE);
 				dataOut.Write((double) value);
 			}
 			else if(value is byte[])
 			{
 				byte[] data = (byte[]) value;
 				dataOut.Write(BYTE_ARRAY_TYPE);
 				dataOut.Write(data.Length);
 				dataOut.Write(data);
 			}
 			else if(value is string)
 			{
 				string s = (string) value;
 				// is the string big??
 				if(s.Length > 8191)
 				{
 					dataOut.Write(BIG_STRING_TYPE);
 					((EndianBinaryWriter) dataOut).WriteString32(s);
 				}
 				else
 				{
 					dataOut.Write(STRING_TYPE);
 					((EndianBinaryWriter) dataOut).WriteString16(s);
 				}
 			}
 			else if(value is IDictionary)
 			{
 				dataOut.Write(MAP_TYPE);
 				MarshalPrimitiveMap((IDictionary) value, dataOut);
 			}
 			else if(value is IList)
 			{
 				dataOut.Write(LIST_TYPE);
 				MarshalPrimitiveList((IList) value, dataOut);
 			}
 			else
 			{
 				throw new IOException("Object is not a primitive: " + value);
 			}
 		}

 		public static Object UnmarshalPrimitive(BinaryReader dataIn)
 		{
 			Object value = null;
 			byte type = dataIn.ReadByte();
 			switch(type)
 			{
 			case NULL:
 				value = null;
 				break;
 			case BYTE_TYPE:
 				value = dataIn.ReadByte();
 				break;
 			case BOOLEAN_TYPE:
 				value = dataIn.ReadBoolean();
 				break;
 			case CHAR_TYPE:
 				value = dataIn.ReadChar();
 				break;
 			case SHORT_TYPE:
 				value = dataIn.ReadInt16();
 				break;
 			case INTEGER_TYPE:
 				value = dataIn.ReadInt32();
 				break;
 			case LONG_TYPE:
 				value = dataIn.ReadInt64();
 				break;
 			case FLOAT_TYPE:
 				value = dataIn.ReadSingle();
 				break;
 			case DOUBLE_TYPE:
 				value = dataIn.ReadDouble();
 				break;
 			case BYTE_ARRAY_TYPE:
 				int size = dataIn.ReadInt32();
 				byte[] data = new byte[size];
 				dataIn.Read(data, 0, size);
 				value = data;
 				break;
 			case STRING_TYPE:
 				value = ((EndianBinaryReader) dataIn).ReadString16();
 				break;
 			case BIG_STRING_TYPE:
 				value = ((EndianBinaryReader) dataIn).ReadString32();
 				break;
 			case MAP_TYPE:
 				value = UnmarshalPrimitiveMap(dataIn);
 				break;
 			case LIST_TYPE:
 				value = UnmarshalPrimitiveList(dataIn);
 				break;

 			default:
 				throw new Exception("Unsupported data type: " + type);
 			}
 			return value;
 		}
 	}
 }
	/*
	* 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.IO;

	namespace Apache.NMS.Util
	{
	/// <summary>
	/// A default implementation of IPrimitiveMap
	/// </summary>
	public class PrimitiveMap : IPrimitiveMap
	{
	public const byte NULL = 0;
	public const byte BOOLEAN_TYPE = 1;
	public const byte BYTE_TYPE = 2;
	public const byte CHAR_TYPE = 3;
	public const byte SHORT_TYPE = 4;
	public const byte INTEGER_TYPE = 5;
	public const byte LONG_TYPE = 6;
	public const byte DOUBLE_TYPE = 7;
	public const byte FLOAT_TYPE = 8;
	public const byte STRING_TYPE = 9;
	public const byte BYTE_ARRAY_TYPE = 10;
	public const byte MAP_TYPE = 11;
	public const byte LIST_TYPE = 12;
	public const byte BIG_STRING_TYPE = 13;

	private IDictionary dictionary = Hashtable.Synchronized(new Hashtable());

	public void Clear()
	{
	dictionary.Clear();
	}

	public bool Contains(Object key)
	{
	return dictionary.Contains(key);
	}

	public void Remove(Object key)
	{
	dictionary.Remove(key);
	}

	public int Count
	{
	get { return dictionary.Count; }
	}

	public ICollection Keys
	{
	get { lock(dictionary.SyncRoot) return new ArrayList(dictionary.Keys); }
	}

	public ICollection Values
	{
	get { lock(dictionary.SyncRoot) return new ArrayList(dictionary.Values); }
	}

	public object this[string key]
	{
	get { return GetValue(key); }
	set
	{
	CheckValidType(value);
	SetValue(key, value);
	}
	}

	public string GetString(string key)
	{
	Object value = GetValue(key);
	if(value == null)
	{
	return null;
	}
	CheckValueType(value, typeof(string));
	return (string) value;
	}

	public void SetString(string key, string value)
	{
	SetValue(key, value);
	}

	public bool GetBool(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(bool));
	return (bool) value;
	}

	public void SetBool(String key, bool value)
	{
	SetValue(key, value);
	}

	public byte GetByte(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(byte));
	return (byte) value;
	}

	public void SetByte(String key, byte value)
	{
	SetValue(key, value);
	}

	public char GetChar(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(char));
	return (char) value;
	}

	public void SetChar(String key, char value)
	{
	SetValue(key, value);
	}

	public short GetShort(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(short));
	return (short) value;
	}

	public void SetShort(String key, short value)
	{
	SetValue(key, value);
	}

	public int GetInt(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(int));
	return (int) value;
	}

	public void SetInt(String key, int value)
	{
	SetValue(key, value);
	}

	public long GetLong(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(long));
	return (long) value;
	}

	public void SetLong(String key, long value)
	{
	SetValue(key, value);
	}

	public float GetFloat(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(float));
	return (float) value;
	}

	public void SetFloat(String key, float value)
	{
	SetValue(key, value);
	}

	public double GetDouble(String key)
	{
	Object value = GetValue(key);
	CheckValueType(value, typeof(double));
	return (double) value;
	}

	public void SetDouble(String key, double value)
	{
	SetValue(key, value);
	}

	public IList GetList(String key)
	{
	Object value = GetValue(key);
	if(value != null && !(value is IList))
	{
	throw new NMSException("Property: " + key + " is not an IList but is: " + value);
	}
	return (IList) value;
	}

	public void SetList(String key, IList value)
	{
	SetValue(key, value);
	}

	public void SetBytes(String key, byte[] value)
	{
	this.SetBytes(key, value, 0, value.Length);
	}

	public void SetBytes(String key, byte[] value, int offset, int length)
	{
	byte[] copy = new byte[length];
	Array.Copy(value, offset, copy, 0, length);
	SetValue(key, copy);
	}

	public byte[] GetBytes(string key)
	{
	Object value = GetValue(key);
	if(value != null && !(value is Byte[]))
	{
	throw new NMSException("Property: " + key + " is not an byte[] but is: " + value);
	}
	return (byte[]) value;
	}

	public IDictionary GetDictionary(String key)
	{
	Object value = GetValue(key);
	if(value != null && !(value is IDictionary))
	{
	throw new NMSException("Property: " + key + " is not an IDictionary but is: " + value);
	}
	return (IDictionary) value;
	}

	public void SetDictionary(String key, IDictionary value)
	{
	SetValue(key, value);
	}

	protected virtual void SetValue(String key, Object value)
	{
	dictionary[key] = value;
	}

	protected virtual Object GetValue(String key)
	{
	return dictionary[key];
	}

	protected virtual void CheckValueType(Object value, Type type)
	{
	if(!type.IsInstanceOfType(value))
	{
	throw new NMSException("Expected type: " + type.Name + " but was: " + value);
	}
	}

	protected virtual void CheckValidType(Object value)
	{
	if(value != null && !(value is IList) && !(value is IDictionary))
	{
	Type type = value.GetType();

	if(type.IsInstanceOfType(typeof(Object)) \|\|
	(!type.IsPrimitive && !type.IsValueType && !type.IsAssignableFrom(typeof(string))))
	{
	throw new NMSException("Invalid type: " + type.Name + " for value: " + value);
	}
	}
	}

	/// <summary>
	/// Method ToString
	/// </summary>
	/// <returns>A string</returns>
	public override String ToString()
	{
	String s = "{";
	bool first = true;
	lock(dictionary.SyncRoot)
	{
	foreach(DictionaryEntry entry in dictionary)
	{
	if(!first)
	{
	s += ", ";
	}
	first = false;
	String name = (String) entry.Key;
	Object value = entry.Value;
	s += name + "=" + value;
	}
	}
	s += "}";
	return s;
	}

	/// <summary>
	/// Unmarshalls the map from the given data or if the data is null just
	/// return an empty map
	/// </summary>
	public static PrimitiveMap Unmarshal(byte[] data)
	{
	PrimitiveMap answer = new PrimitiveMap();
	answer.dictionary = UnmarshalPrimitiveMap(data);
	return answer;
	}

	/// <summary>
	/// Unmarshals a PrimitiveMap directly from a Stream object. This
	/// allows for clients to read PrimitiveMaps from Compressed or other
	/// wise encoded streams without this class needing to know about it.
	/// </summary>
	/// <param name="source">
	/// A <see cref="Stream"/>
	/// </param>
	/// <returns>
	/// A <see cref="PrimitiveMap"/>
	/// </returns>
	public static PrimitiveMap Unmarshal(Stream source)
	{
	PrimitiveMap answer = new PrimitiveMap();
	answer.dictionary = UnmarshalPrimitiveMap(source);
	return answer;
	}

	public byte[] Marshal()
	{
	lock(dictionary.SyncRoot)
	{
	return MarshalPrimitiveMap(dictionary);
	}
	}

	/// <summary>
	/// Marshals a PrimitiveMap directly to a Stream object. This
	/// allows a client to write a PrimitiveMap in a compressed or
	/// otherwise encoded form without this class needing to know
	/// about it.
	/// </summary>
	/// <param name="destination">
	/// A <see cref="Stream"/>
	/// </param>
	public void Marshal(Stream destination)
	{
	lock(dictionary.SyncRoot)
	{
	MarshalPrimitiveMap(dictionary, destination);
	}
	}

	/// <summary>
	/// Marshals the primitive type map to a byte array
	/// </summary>
	public static byte[] MarshalPrimitiveMap(IDictionary map)
	{
	if(map == null)
	{
	return null;
	}

	MemoryStream memoryStream = new MemoryStream();
	lock(map.SyncRoot)
	{
	MarshalPrimitiveMap(map, new EndianBinaryWriter(memoryStream));
	}

	return memoryStream.ToArray();
	}

	public static void MarshalPrimitiveMap(IDictionary map, Stream stream)
	{
	if(map != null)
	{
	lock(map.SyncRoot)
	{
	MarshalPrimitiveMap(map, new EndianBinaryWriter(stream));
	}
	}
	}

	public static void MarshalPrimitiveMap(IDictionary map, BinaryWriter dataOut)
	{
	if(map == null)
	{
	dataOut.Write((int) -1);
	}
	else
	{
	lock(map.SyncRoot)
	{
	dataOut.Write(map.Count);
	foreach(DictionaryEntry entry in map)
	{
	String name = (String) entry.Key;
	dataOut.Write(name);
	Object value = entry.Value;
	MarshalPrimitive(dataOut, value);
	}
	}
	}
	}

	/// <summary>
	/// Unmarshals the primitive type map from the given byte array
	/// </summary>
	public static IDictionary UnmarshalPrimitiveMap(byte[] data)
	{
	if(data == null)
	{
	return new Hashtable();
	}
	else
	{
	return UnmarshalPrimitiveMap(new EndianBinaryReader(new MemoryStream(data)));
	}
	}

	public static IDictionary UnmarshalPrimitiveMap(Stream source)
	{
	return UnmarshalPrimitiveMap(new EndianBinaryReader(source));
	}

	public static IDictionary UnmarshalPrimitiveMap(BinaryReader dataIn)
	{
	int size = dataIn.ReadInt32();
	if(size < 0)
	{
	return null;
	}

	IDictionary answer = new Hashtable(size);
	for(int i = 0; i < size; i++)
	{
	String name = dataIn.ReadString();
	answer[name] = UnmarshalPrimitive(dataIn);
	}

	return answer;
	}

	public static void MarshalPrimitiveList(IList list, BinaryWriter dataOut)
	{
	dataOut.Write((int) list.Count);
	foreach(Object element in list)
	{
	MarshalPrimitive(dataOut, element);
	}
	}

	public static IList UnmarshalPrimitiveList(BinaryReader dataIn)
	{
	int size = dataIn.ReadInt32();
	IList answer = new ArrayList(size);
	while(size-- > 0)
	{
	answer.Add(UnmarshalPrimitive(dataIn));
	}

	return answer;
	}

	public static void MarshalPrimitive(BinaryWriter dataOut, Object value)
	{
	if(value == null)
	{
	dataOut.Write(NULL);
	}
	else if(value is bool)
	{
	dataOut.Write(BOOLEAN_TYPE);
	dataOut.Write((bool) value);
	}
	else if(value is byte)
	{
	dataOut.Write(BYTE_TYPE);
	dataOut.Write(((byte) value));
	}
	else if(value is char)
	{
	dataOut.Write(CHAR_TYPE);
	dataOut.Write((char) value);
	}
	else if(value is short)
	{
	dataOut.Write(SHORT_TYPE);
	dataOut.Write((short) value);
	}
	else if(value is int)
	{
	dataOut.Write(INTEGER_TYPE);
	dataOut.Write((int) value);
	}
	else if(value is long)
	{
	dataOut.Write(LONG_TYPE);
	dataOut.Write((long) value);
	}
	else if(value is float)
	{
	dataOut.Write(FLOAT_TYPE);
	dataOut.Write((float) value);
	}
	else if(value is double)
	{
	dataOut.Write(DOUBLE_TYPE);
	dataOut.Write((double) value);
	}
	else if(value is byte[])
	{
	byte[] data = (byte[]) value;
	dataOut.Write(BYTE_ARRAY_TYPE);
	dataOut.Write(data.Length);
	dataOut.Write(data);
	}
	else if(value is string)
	{
	string s = (string) value;
	// is the string big??
	if(s.Length > 8191)
	{
	dataOut.Write(BIG_STRING_TYPE);
	((EndianBinaryWriter) dataOut).WriteString32(s);
	}
	else
	{
	dataOut.Write(STRING_TYPE);
	((EndianBinaryWriter) dataOut).WriteString16(s);
	}
	}
	else if(value is IDictionary)
	{
	dataOut.Write(MAP_TYPE);
	MarshalPrimitiveMap((IDictionary) value, dataOut);
	}
	else if(value is IList)
	{
	dataOut.Write(LIST_TYPE);
	MarshalPrimitiveList((IList) value, dataOut);
	}
	else
	{
	throw new IOException("Object is not a primitive: " + value);
	}
	}

	public static Object UnmarshalPrimitive(BinaryReader dataIn)
	{
	Object value = null;
	byte type = dataIn.ReadByte();
	switch(type)
	{
	case NULL:
	value = null;
	break;
	case BYTE_TYPE:
	value = dataIn.ReadByte();
	break;
	case BOOLEAN_TYPE:
	value = dataIn.ReadBoolean();
	break;
	case CHAR_TYPE:
	value = dataIn.ReadChar();
	break;
	case SHORT_TYPE:
	value = dataIn.ReadInt16();
	break;
	case INTEGER_TYPE:
	value = dataIn.ReadInt32();
	break;
	case LONG_TYPE:
	value = dataIn.ReadInt64();
	break;
	case FLOAT_TYPE:
	value = dataIn.ReadSingle();
	break;
	case DOUBLE_TYPE:
	value = dataIn.ReadDouble();
	break;
	case BYTE_ARRAY_TYPE:
	int size = dataIn.ReadInt32();
	byte[] data = new byte[size];
	dataIn.Read(data, 0, size);
	value = data;
	break;
	case STRING_TYPE:
	value = ((EndianBinaryReader) dataIn).ReadString16();
	break;
	case BIG_STRING_TYPE:
	value = ((EndianBinaryReader) dataIn).ReadString32();
	break;
	case MAP_TYPE:
	value = UnmarshalPrimitiveMap(dataIn);
	break;
	case LIST_TYPE:
	value = UnmarshalPrimitiveList(dataIn);
	break;

	default:
	throw new Exception("Unsupported data type: " + type);
	}
	return value;
	}
	}
	}