namespace OXT.Utils
{
	[XmlRoot("dictionary")]
	public class SerializableDictionary<TKey, TValue>; : Dictionary<TKey, TValue>, IXmlSerializable
	{
		#region IXmlSerializable Members
 
		public XmlSchema GetSchema()
		{
			return null;
		}
 
		public void ReadXml(XmlReader reader)
		{
			XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
			XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
			// element is empty
			if (reader.IsEmptyElement)
			{
				reader.Read();
				return;
			}
 
			// reading initial element
			reader.Read();
			while (reader.NodeType != XmlNodeType.EndElement)
			{
				reader.ReadStartElement("item");
 
				reader.ReadStartElement("key");
				TKey key = (TKey)keySerializer.Deserialize(reader);
				reader.ReadEndElement();
 
				reader.ReadStartElement("value");
				TValue value = (TValue)valueSerializer.Deserialize(reader);
				reader.ReadEndElement();
 
				Add(key, value);
 
				reader.ReadEndElement();
				reader.MoveToContent();
			}
 
			reader.ReadEndElement();
		}
 
		public void WriteXml(XmlWriter writer)
		{
			XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
			XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
			foreach (TKey key in Keys)
			{
				writer.WriteStartElement("item");
 
				writer.WriteStartElement("key");
				keySerializer.Serialize(writer, key);
				writer.WriteEndElement();
 
				writer.WriteStartElement("value");
				valueSerializer.Serialize(writer, this[key]);
				writer.WriteEndElement();
 
				writer.WriteEndElement();
			}
		}
 
		#endregion
	}
 
}

namespace OXT.Utils
{
	[Serializable]
	public class Pair<TFirst, TSecond>;
	{
		public Pair()
		{
		}
 
		public Pair(TFirst first, TSecond second)
		{
			this.first = first;
			this.second = second;
		}
 
		private TFirst first;
		public TFirst First
		{
			get { return first; }
			set { first = value; }
		}
 
		private TSecond second;
		public TSecond Second
		{
			get { return second; }
			set { second = value; }
		}
 
		public override bool Equals(object obj)
		{
			if (this == obj) return true;
			Pair<TFirst, TSecond> pair = obj as Pair<TFirst, TSecond>;
			if (pair == null) return false;
			return Equals(first, pair.first) && Equals(second, pair.second);
		}
 
		public override int GetHashCode()
		{
			return (first != null ? first.GetHashCode() : 0) + 29*(second != null ? second.GetHashCode() : 0);
		}
 
		public static List<Pair<TFirst, TSecond>> Dictionary2List(IDictionary<TFirst, TSecond> dictionary)
		{
			List<Pair<TFirst, TSecond>> result = new List<Pair<TFirst, TSecond>>();
			if (dictionary != null)
			{
				foreach (KeyValuePair<TFirst, TSecond> pair in dictionary)
				{
					result.Add(new Pair<TFirst, TSecond>(pair.Key, pair.Value));
				}
			}
			return result;
		}
 
		public static Dictionary<TFirst, TSecond> List2Dictionary(IList<Pair<TFirst, TSecond>> list)
		{
			Dictionary<TFirst, TSecond> result = new Dictionary<TFirst, TSecond>();
			if (list != null)
			{
				foreach (Pair<TFirst, TSecond> pair in list)
				{
					result.Add(pair.First, pair.Second);
				}
			}
			return result;
		}
 
		public static Dictionary<TFirst, List<TSecond>> List2TwoDimentionalDictionary(IList<Pair<TFirst, TSecond>> list)
		{
			Dictionary<TFirst, List<TSecond>> result = new Dictionary<TFirst, List<TSecond>>();
			if (list != null)
			{
				foreach (Pair<TFirst, TSecond> pair in list)
				{
					List<TSecond> dimentionList;
					if (!result.TryGetValue(pair.First, out dimentionList))
					{
						dimentionList = new List<TSecond>();
						result[pair.First] = dimentionList;
					}
 
					dimentionList.Add(pair.Second);
				}
			}
			return result;
		}
 
	}