PclExportClient.cs

//
// System.Collections.Specialized.NameObjectCollectionBase.cs
//
// Author:
//   Gleb Novodran
//   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
//
// (C) Ximian, Inc.  http://www.ximian.com
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

/*** REMINDER: Keep this file in sync with ServiceStack.Text/Pcl.NameValueCollection.cs ***/

using System.IO;
using System.Net;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using ServiceStack.Text;
using System.Globalization;

#if NETFX_CORE || PCL || SL5 || NETSTANDARD1_1 
//namespace System.Collections.Specialized
namespace ServiceStack.Pcl
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Net;
    using System.Reflection;
    using System.Runtime.Serialization;
    using System.Text;

    public class Hashtable : Dictionary<string, object>
    {
        public Hashtable(IDictionary<string, object> dictionary, IEqualityComparer<string> comparer) : base(dictionary, comparer) {}
        public Hashtable(int capacity, IEqualityComparer<string> comparer) : base(capacity, comparer) {}
        public Hashtable(int capacity) : base(capacity) {}
        public Hashtable(IDictionary<string, object> dictionary) : base(dictionary) {}
        public Hashtable(IEqualityComparer<string> comparer) : base(comparer) {}
        public Hashtable() {}
    }

    public class SerializableAttribute : Attribute {}
    public class ArrayList : List<object>{}

    public class StringEqualityComparer : IEqualityComparer<string>
    {
        private readonly IEqualityComparer comparer;

        public StringEqualityComparer(IEqualityComparer comparer)
        {
            this.comparer = comparer;
        }

        public bool Equals(string x, string y)
        {
            if (x == null && y == null) return true;
            if (x == null || y == null) return false;
            return comparer.Equals(x, y);
        }

        public int GetHashCode(string obj)
        {
            return comparer.GetHashCode(obj);
        }
    }

    [Serializable]
    public abstract class NameObjectCollectionBase : ICollection, IEnumerable
        //, ISerializable, IDeserializationCallback
    {
        private Hashtable m_ItemsContainer;
        /// <summary>
        /// Extends Hashtable based Items container to support storing null-key pairs
        /// </summary>
        private _Item m_NullKeyItem;
        private ArrayList m_ItemsArray;
        private IComparer m_comparer;
        private int m_defCapacity;
        private bool m_readonly;
        SerializationInfo infoCopy;
        private KeysCollection keyscoll;
        private IEqualityComparer equality_comparer;

        internal IEqualityComparer EqualityComparer
        {
            get { return equality_comparer; }
        }

        internal IComparer Comparer
        {
            get { return m_comparer; }
        }

        internal class _Item
        {
            public string key;
            public object value;
            public _Item(string key, object value)
            {
                this.key = key;
                this.value = value;
            }
        }
        /// <summary>
        /// Implements IEnumerable interface for KeysCollection
        /// </summary>
        [Serializable]
        internal class _KeysEnumerator : IEnumerator
        {
            private NameObjectCollectionBase m_collection;
            private int m_position;

            internal _KeysEnumerator(NameObjectCollectionBase collection)
            {
                m_collection = collection;
                Reset();
            }
            public object Current
            {

                get
                {
                    if ((m_position < m_collection.Count) || (m_position < 0))
                        return m_collection.BaseGetKey(m_position);
                    else
                        throw new InvalidOperationException();
                }

            }
            public bool MoveNext()
            {
                return ((++m_position) < m_collection.Count);
            }
            public void Reset()
            {
                m_position = -1;
            }
        }

        /// <summary>
        /// SDK: Represents a collection of the String keys of a collection.
        /// </summary>
        [Serializable]
        public class KeysCollection : ICollection, IEnumerable
        {
            private NameObjectCollectionBase m_collection;

            internal KeysCollection(NameObjectCollectionBase collection)
            {
                this.m_collection = collection;
            }

            public virtual string Get(int index)
            {
                return m_collection.BaseGetKey(index);
            }

            // ICollection methods -----------------------------------
            void ICollection.CopyTo(Array array, int arrayIndex)
            {
                ArrayList items = m_collection.m_ItemsArray;
                if (null == array)
                    throw new ArgumentNullException("array");

                if (arrayIndex < 0)
                    throw new ArgumentOutOfRangeException("arrayIndex");

                if ((array.Length > 0) && (arrayIndex >= array.Length))
                    throw new ArgumentException("arrayIndex is equal to or greater than array.Length");

                if (arrayIndex + items.Count > array.Length)
                    throw new ArgumentException("Not enough room from arrayIndex to end of array for this KeysCollection");

                if (array != null && array.Rank > 1)
                    throw new ArgumentException("array is multidimensional");

                object[] objArray = (object[])array;
                for (int i = 0; i < items.Count; i++, arrayIndex++)
                    objArray[arrayIndex] = ((_Item)items[i]).key;
            }

            bool ICollection.IsSynchronized
            {
                get
                {
                    return false;
                }
            }
            object ICollection.SyncRoot
            {
                get
                {
                    return m_collection;
                }
            }
            /// <summary>
            /// Gets the number of keys in the NameObjectCollectionBase.KeysCollection
            /// </summary>
            public int Count
            {
                get
                {
                    return m_collection.Count;
                }
            }

            public string this[int index]
            {
                get { return Get(index); }
            }

            // IEnumerable methods --------------------------------
            /// <summary>
            /// SDK: Returns an enumerator that can iterate through the NameObjectCollectionBase.KeysCollection.
            /// </summary>
            /// <returns></returns>
            public IEnumerator GetEnumerator()
            {
                return new _KeysEnumerator(m_collection);
            }
        }

        //--------------- Protected Instance Constructors --------------

        /// <summary>
        /// SDK: Initializes a new instance of the NameObjectCollectionBase class that is empty.
        /// </summary>
        protected NameObjectCollectionBase()
        {
            m_readonly = false;
            m_comparer = StringComparer.Ordinal;
            m_defCapacity = 0;
            Init();
        }

        protected NameObjectCollectionBase(int capacity)
        {
            m_readonly = false;
            m_comparer = StringComparer.Ordinal;
            m_defCapacity = capacity;
            Init();
        }

        protected NameObjectCollectionBase(IEqualityComparer equalityComparer)
            : this(0, (equalityComparer ?? StringComparer.OrdinalIgnoreCase))
        {
        }

        protected NameObjectCollectionBase(SerializationInfo info, StreamingContext context)
        {
            infoCopy = info;
        }

        protected NameObjectCollectionBase(int capacity, IEqualityComparer equalityComparer)
        {
            m_readonly = false;
            equality_comparer = (equalityComparer ?? StringComparer.OrdinalIgnoreCase);
            m_defCapacity = capacity;
            Init();
        }

        private void Init()
        {
            if (m_ItemsContainer != null)
            {
                m_ItemsContainer.Clear();
                m_ItemsContainer = null;
            }

            if (m_ItemsArray != null)
            {
                m_ItemsArray.Clear();
                m_ItemsArray = null;
            }

            if (equality_comparer == null)
                equality_comparer = StringComparer.OrdinalIgnoreCase;

            m_ItemsContainer = new Hashtable(m_defCapacity, new StringEqualityComparer(equality_comparer));
            m_ItemsArray = new ArrayList();
            m_NullKeyItem = null;
        }

        //--------------- Public Instance Properties -------------------

        public virtual NameObjectCollectionBase.KeysCollection Keys
        {
            get
            {
                if (keyscoll == null)
                    keyscoll = new KeysCollection(this);
                return keyscoll;
            }
        }

        //--------------- Public Instance Methods ----------------------
        // 
        /// <summary>
        /// SDK: Returns an enumerator that can iterate through the NameObjectCollectionBase.
        /// 
        /// <remark>This enumerator returns the keys of the collection as strings.</remark>
        /// </summary>
        /// <returns></returns>
        public virtual IEnumerator GetEnumerator()
        {
            return new _KeysEnumerator(this);
        }

        // ISerializable
        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
                throw new ArgumentNullException("info");

            int count = Count;
            string[] keys = new string[count];
            object[] values = new object[count];
            int i = 0;
            foreach (_Item item in m_ItemsArray)
            {
                keys[i] = item.key;
                values[i] = item.value;
                i++;
            }

            info.AddValue("KeyComparer", equality_comparer, typeof(IEqualityComparer));
            info.AddValue("Version", 4, typeof(int));

            info.AddValue("ReadOnly", m_readonly);
            info.AddValue("Count", count);
            info.AddValue("Keys", keys, typeof(string[]));
            info.AddValue("Values", values, typeof(object[]));
        }

        // ICollection
        public virtual int Count
        {
            get
            {
                return m_ItemsArray.Count;
            }
        }

        bool ICollection.IsSynchronized
        {
            get { return false; }
        }

        object ICollection.SyncRoot
        {
            get { return this; }
        }

        void ICollection.CopyTo(Array array, int index)
        {
            ((ICollection)Keys).CopyTo(array, index);
        }

        // IDeserializationCallback
        public virtual void OnDeserialization(object sender)
        {
            SerializationInfo info = infoCopy;

            // If a subclass overrides the serialization constructor
            // and inplements its own serialization process, infoCopy will
            // be null and we can ignore this callback.
            if (info == null)
                return;

            infoCopy = null;

            m_comparer = (IComparer)info.GetValue("Comparer", typeof(IComparer));
            if (m_comparer == null)
                throw new SerializationException("The comparer is null");

            m_readonly = info.GetBoolean("ReadOnly");
            string[] keys = (string[])info.GetValue("Keys", typeof(string[]));
            if (keys == null)
                throw new SerializationException("keys is null");

            object[] values = (object[])info.GetValue("Values", typeof(object[]));
            if (values == null)
                throw new SerializationException("values is null");

            Init();
            int count = keys.Length;
            for (int i = 0; i < count; i++)
                BaseAdd(keys[i], values[i]);
        }

        //--------------- Protected Instance Properties ----------------
        /// <summary>
        /// SDK: Gets or sets a value indicating whether the NameObjectCollectionBase instance is read-only.
        /// </summary>
        protected bool IsReadOnly
        {
            get
            {
                return m_readonly;
            }
            set
            {
                m_readonly = value;
            }
        }

        //--------------- Protected Instance Methods -------------------
        /// <summary>
        /// Adds an Item with the specified key and value into the <see cref="NameObjectCollectionBase"/>NameObjectCollectionBase instance.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        protected void BaseAdd(string name, object value)
        {
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");

            _Item newitem = new _Item(name, value);

            if (name == null)
            {
                //todo: consider nullkey entry
                if (m_NullKeyItem == null)
                    m_NullKeyItem = newitem;
            }
            else
                if (!HasItem(name))
                {
                    m_ItemsContainer.Add(name, newitem);
                }
            m_ItemsArray.Add(newitem);
        }

        protected void BaseClear()
        {
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");
            Init();
        }

        /// <summary>
        /// SDK: Gets the value of the entry at the specified index of the NameObjectCollectionBase instance.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        protected object BaseGet(int index)
        {
            return ((_Item)m_ItemsArray[index]).value;
        }

        /// <summary>
        /// SDK: Gets the value of the first entry with the specified key from the NameObjectCollectionBase instance.
        /// </summary>
        /// <remark>CAUTION: The BaseGet method does not distinguish between a null reference which is returned because the specified key is not found and a null reference which is returned because the value associated with the key is a null reference.</remark>
        /// <param name="name"></param>
        /// <returns></returns>
        protected object BaseGet(string name)
        {
            _Item item = FindFirstMatchedItem(name);
            /// CAUTION: The BaseGet method does not distinguish between a null reference which is returned because the specified key is not found and a null reference which is returned because the value associated with the key is a null reference.
            if (item == null)
                return null;
            else
                return item.value;
        }

        /// <summary>
        /// SDK:Returns a String array that contains all the keys in the NameObjectCollectionBase instance.
        /// </summary>
        /// <returns>A String array that contains all the keys in the NameObjectCollectionBase instance.</returns>
        protected string[] BaseGetAllKeys()
        {
            int cnt = m_ItemsArray.Count;
            string[] allKeys = new string[cnt];
            for (int i = 0; i < cnt; i++)
                allKeys[i] = BaseGetKey(i);//((_Item)m_ItemsArray[i]).key;

            return allKeys;
        }

        /// <summary>
        /// SDK: Returns an Object array that contains all the values in the NameObjectCollectionBase instance.
        /// </summary>
        /// <returns>An Object array that contains all the values in the NameObjectCollectionBase instance.</returns>
        protected object[] BaseGetAllValues()
        {
            int cnt = m_ItemsArray.Count;
            object[] allValues = new object[cnt];
            for (int i = 0; i < cnt; i++)
                allValues[i] = BaseGet(i);

            return allValues;
        }

        protected object[] BaseGetAllValues(Type type)
        {
            if (type == null)
                throw new ArgumentNullException("'type' argument can't be null");
            int cnt = m_ItemsArray.Count;
            object[] allValues = (object[])Array.CreateInstance(type, cnt);
            for (int i = 0; i < cnt; i++)
                allValues[i] = BaseGet(i);

            return allValues;
        }

        protected string BaseGetKey(int index)
        {
            return ((_Item)m_ItemsArray[index]).key;
        }

        /// <summary>
        /// Gets a value indicating whether the NameObjectCollectionBase instance contains entries whose keys are not a null reference 
        /// </summary>
        /// <returns>true if the NameObjectCollectionBase instance contains entries whose keys are not a null reference otherwise, false.</returns>
        protected bool BaseHasKeys()
        {
            return (m_ItemsContainer.Count > 0);
        }

        protected void BaseRemove(string name)
        {
            int cnt = 0;
            String key;
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");
            if (name != null)
            {
                m_ItemsContainer.Remove(name);
            }
            else
            {
                m_NullKeyItem = null;
            }

            cnt = m_ItemsArray.Count;
            for (int i = 0; i < cnt; )
            {
                key = BaseGetKey(i);
                if (Equals(key, name))
                {
                    m_ItemsArray.RemoveAt(i);
                    cnt--;
                }
                else
                    i++;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <LAME>This function implemented the way Microsoft implemented it - 
        /// item is removed from hashtable and array without considering the case when there are two items with the same key but different values in array.
        /// E.g. if
        /// hashtable is [("Key1","value1")] and array contains [("Key1","value1")("Key1","value2")] then
        /// after RemoveAt(1) the collection will be in following state:
        /// hashtable:[] 
        /// array: [("Key1","value1")] 
        /// It's ok only then the key is uniquely assosiated with the value
        /// To fix it a comparsion of objects stored under the same key in the hashtable and in the arraylist should be added 
        /// </LAME>>
        protected void BaseRemoveAt(int index)
        {
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");
            string key = BaseGetKey(index);
            if (key != null)
            {
                // TODO: see LAME description above
                m_ItemsContainer.Remove(key);
            }
            else
                m_NullKeyItem = null;
            m_ItemsArray.RemoveAt(index);
        }

        /// <summary>
        /// SDK: Sets the value of the entry at the specified index of the NameObjectCollectionBase instance.
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        protected void BaseSet(int index, object value)
        {
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");
            _Item item = (_Item)m_ItemsArray[index];
            item.value = value;
        }

        /// <summary>
        /// Sets the value of the first entry with the specified key in the NameObjectCollectionBase instance, if found; otherwise, adds an entry with the specified key and value into the NameObjectCollectionBase instance.
        /// </summary>
        /// <param name="name">The String key of the entry to set. The key can be a null reference </param>
        /// <param name="value">The Object that represents the new value of the entry to set. The value can be a null reference</param>
        protected void BaseSet(string name, object value)
        {
            if (this.IsReadOnly)
                throw new NotSupportedException("Collection is read-only");
            _Item item = FindFirstMatchedItem(name);
            if (item != null)
                item.value = value;
            else
                BaseAdd(name, value);
        }

        private bool HasItem(string name)
        {
            return FindFirstMatchedItem(name) != m_NullKeyItem;
        }

        //[MonoTODO]
        private _Item FindFirstMatchedItem(string name)
        {
            if (name != null)
            {
                object value;
                if (m_ItemsContainer.TryGetValue(name, out value))
                    return (value as _Item) ?? m_NullKeyItem;

                return m_NullKeyItem;
            }
            
            //TODO: consider null key case
            return m_NullKeyItem;
        }

        internal bool Equals(string s1, string s2)
        {
            if (m_comparer != null)
                return (m_comparer.Compare(s1, s2) == 0);
            else
                return equality_comparer.Equals(s1, s2);
        }
    }

	[Serializable]
	public class NameValueCollection : NameObjectCollectionBase
	{
		string[] cachedAllKeys = null;
		string[] cachedAll = null;

		//--------------------- Constructors -----------------------------

		public NameValueCollection () : base ()
		{
		}
		
		public NameValueCollection (int capacity) : base (capacity)
		{
		}
		
		public NameValueCollection (NameValueCollection col) 
            : base(col.EqualityComparer)
		{
			if (col==null)
				throw new ArgumentNullException ("col");		
			Add(col);
		}

		protected NameValueCollection (SerializationInfo info, StreamingContext context)
			:base (info, context)
		{
			
		}

		public NameValueCollection (IEqualityComparer equalityComparer)
			: base (equalityComparer)
		{
		}

		public NameValueCollection (int capacity, IEqualityComparer equalityComparer)
			: base (capacity, equalityComparer)
		{
		}

		public virtual string[] AllKeys 
		{
			get {
				if (cachedAllKeys == null)
					cachedAllKeys = BaseGetAllKeys ();
				return this.cachedAllKeys;
			}
		}
		
		public string this [int index] 
		{
			get{
				return this.Get (index);
			}
		}
		
		public string this [string name] {
			get{
				return this.Get (name);
			}
			set{
				this.Set (name,value);
			}
		}
		
		public void Add (NameValueCollection c)
		{
			if (this.IsReadOnly)
				throw new NotSupportedException ("Collection is read-only");
			if (c == null)
				throw new ArgumentNullException ("c");

// make sense - but it's not the exception thrown
//				throw new ArgumentNullException ();
			
			InvalidateCachedArrays ();
			int max = c.Count;
			for (int i=0; i < max; i++){
				string key = c.GetKey (i);
				string[] values = c.GetValues (i);

				if (values != null && values.Length > 0) {
					foreach (string value in values)
						Add (key, value);
				} else
					Add (key, null);
			}
		}

		/// in SDK doc: If the same value already exists under the same key in the collection, 
		/// it just adds one more value in other words after
		/// <code>
		/// NameValueCollection nvc;
		/// nvc.Add ("LAZY","BASTARD")
		/// nvc.Add ("LAZY","BASTARD")
		/// </code>
		/// nvc.Get ("LAZY") will be "BASTARD,BASTARD" instead of "BASTARD"

		public virtual void Add (string name, string value)
		{
			if (this.IsReadOnly)
				throw new NotSupportedException ("Collection is read-only");
			
			InvalidateCachedArrays ();
			ArrayList values = (ArrayList)BaseGet (name);
			if (values == null){
				values = new ArrayList ();
				if (value != null)
					values.Add (value);
				BaseAdd (name, values);
			}
			else {
				if (value != null)
					values.Add (value);
			}

		}

		public virtual void Clear ()
		{
			if (this.IsReadOnly)
				throw new NotSupportedException ("Collection is read-only");
			InvalidateCachedArrays ();
			BaseClear ();
		}

		public void CopyTo (Array dest, int index)
		{
			if (dest == null)
				throw new ArgumentNullException ("dest", "Null argument - dest");
			if (index < 0)
				throw new ArgumentOutOfRangeException ("index", "index is less than 0");
			if (dest.Rank > 1)
				throw new ArgumentException ("dest", "multidim");

			if (cachedAll == null)
				RefreshCachedAll ();
			try {
				cachedAll.CopyTo (dest, index);
		        } catch (ArrayTypeMismatchException) {
		        	throw new InvalidCastException();
		        }
		}

		private void RefreshCachedAll ()
		{
			this.cachedAll = null;
			int max = this.Count;
			cachedAll = new string [max];
			for (int i = 0; i < max; i++)
				cachedAll [i] = this.Get (i);
		}
		
		public virtual string Get (int index)
		{
			ArrayList values = (ArrayList)BaseGet (index);
			// if index is out of range BaseGet throws an ArgumentOutOfRangeException

			return AsSingleString (values);
		}
		
		public virtual string Get (string name)
		{
			ArrayList values = (ArrayList)BaseGet (name);
			return AsSingleString (values);
		}

		private static string AsSingleString (ArrayList values)
		{
			const char separator = ',';
			
			if (values == null)
				return null;
			int max = values.Count;
			
			switch (max) {
			case 0:
				return null;
			case 1:
				return (string)values [0];
			case 2:
				return String.Concat ((string)values [0], separator, (string)values [1]);
			default:
				int len = max;
				for (int i = 0; i < max; i++)
					len += ((string)values [i]).Length;
				StringBuilder sb = new StringBuilder ((string)values [0], len);
				for (int i = 1; i < max; i++){
					sb.Append (separator);
					sb.Append (values [i]);
				}

				return sb.ToString ();
			}
		}
		
		
		public virtual string GetKey (int index)
		{
			return BaseGetKey (index);
		}
		
		
		public virtual string[] GetValues (int index)
		{
			ArrayList values = (ArrayList)BaseGet (index);
			
			return AsStringArray (values);
		}
		
		
		public virtual string[] GetValues (string name)
		{
			ArrayList values = (ArrayList)BaseGet (name);
			
			return AsStringArray (values);
		}
		
		private static string[] AsStringArray (ArrayList values)
		{
			if (values == null)
				return null;
			int max = values.Count;//get_Count ();
			if (max == 0)
				return null;
			
			string[] valArray = new string[max];
			values.CopyTo (valArray);
			return valArray;
		}
		
		public bool HasKeys ()
		{
			return BaseHasKeys ();
		}
		
		public virtual void Remove (string name)
		{
			if (this.IsReadOnly)
				throw new NotSupportedException ("Collection is read-only");
			InvalidateCachedArrays ();
			BaseRemove (name);
			
		}
		
		public virtual void Set (string name, string value)
		{
			if (this.IsReadOnly)
				throw new NotSupportedException ("Collection is read-only");

			InvalidateCachedArrays ();
			
			ArrayList values = new ArrayList ();
			if (value != null) {
				values.Add (value);
				BaseSet (name,values);
			}
			else {
				// remove all entries
				BaseSet (name, null);
			}
		}
		
		protected void InvalidateCachedArrays ()
		{
			cachedAllKeys = null;
			cachedAll = null;
		}

	}
}

//namespace System.Runtime.Serialization
namespace ServiceStack.Pcl
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using System.Text;
    using ServiceStack;

    public sealed class SerializationInfo
    {
        Dictionary<string, SerializationEntry> serialized = new Dictionary<string, SerializationEntry>();
        List<SerializationEntry> values = new List<SerializationEntry>();

        string assemblyName; // the assembly being serialized
        string fullTypeName; // the type being serialized.
#if NET_4_0
        Type objectType;
        bool isAssemblyNameSetExplicit;
        bool isFullTypeNameSetExplicit;
#endif

        IFormatterConverter converter;

        /* used by the runtime */
        private SerializationInfo(Type type)
        {
            assemblyName = type.AssemblyQualifiedName;
            fullTypeName = type.FullName;
            converter = new FormatterConverter();
#if NET_4_0
            objectType = type;
#endif
        }

        /* used by the runtime */
        private SerializationInfo(Type type, SerializationEntry[] data)
        {
            int len = data.Length;

            assemblyName = type.AssemblyQualifiedName;
            fullTypeName = type.FullName;
            converter = new FormatterConverter();
#if NET_4_0
            objectType = type;
#endif

            for (int i = 0; i < len; i++)
            {
                serialized.Add(data[i].Name, data[i]);
                values.Add(data[i]);
            }
        }

        // Constructor
        [CLSCompliant(false)]
        public SerializationInfo(Type type, IFormatterConverter converter)
        {
            if (type == null)
                throw new ArgumentNullException("type", "Null argument");

            if (converter == null)
                throw new ArgumentNullException("converter", "Null argument");

            this.converter = converter;
            assemblyName = type.AssemblyQualifiedName;
            fullTypeName = type.FullName;
#if NET_4_0
                        objectType = type;