MuratYaman.co.uk

using System;
using System.Collections;
using System.Collections.Generic;
 
namespace MyNamespace
{
    class CAssocArray<T> : System.Collections.IEnumerable
    {
        public const bool USE_INT_AUTOINDEX = true;
        public const int INDEX_TYPE_INT = 0;
        public const int INDEX_TYPE_STRING = 1;
 
        public enum INDEX_TYPE {INTEGER, STRING};
 
        private const int nil = -9999999;
        private int my_max_key;//my_min_key, my_first_key, my_last_key;
 
        private Dictionary<int, T> d;
 
        //if true, it is like 0-based normal array, sequential numbers will be used as keys
        private bool isIntAutoIndexed;
        private INDEX_TYPE index_type;
 
        public CAssocArray()
        {
            this.init(0, true);
        }
 
        public CAssocArray(CAssocArray<T> a)
        {
            this.init(a.index_type, a.isIntAutoIndexed);
            foreach (int k in a.d.Keys)
            {
                //Object o = a.d[k]; T t = (T) o; this.d[k] = t.MemberwiseClone();
                this.d[k] = a.d[k];
            }
        }
 
        public CAssocArray(INDEX_TYPE index_type, bool isIntAutoIndexed)
        {
            this.init(index_type, isIntAutoIndexed);
        }
 
        private void init(INDEX_TYPE index_type, bool isIntAutoIndexed)
        {
            my_max_key = nil;//my_first_key = nil; my_last_key = nil;
            d = new Dictionary<int, T>();
            this.index_type = index_type;
            this.isIntAutoIndexed = isIntAutoIndexed;
        }
        public bool isIndexType_Int()
        {
            return this.index_type == CAssocArray<T>.INDEX_TYPE.INTEGER;//INDEX_TYPE_INT;
        }
        public bool isIndexType_String()
        {
            return this.index_type == CAssocArray<T>.INDEX_TYPE.STRING;//INDEX_TYPE_STRING;
        }
        public int size()//alias for c++ "vector" class
        {
            return d.Count;
        }
 
        public int Length()
        {
            return d.Count;
        }
 
        public int Count()
        {
            return d.Count;
        }
 
        public void push_back(T value)//alias for c++ "vector" class
        {
            this.insert(value);
        }
 
        /**
         * Insert value, use the next number in the sequence as key
         */
        public void insert(T value)
        {
            if (my_max_key == nil) my_max_key = -1;
            int key = (my_max_key + 1);
            //string skey = key.ToString();
            this.insert(key, value);
        }
 
        public void insert(string strKey, T value)
        {
            int key = strKey.GetHashCode();
            this.insert(key, value);
        }
 
        public void insert(int key, T value)
        {
            d.Add(key, value);
            if (key > my_max_key) my_max_key = key;
        }
 
 
        public bool remove(int key)
        {
            bool r = false;
            if (key != nil)
            {
                if (d.ContainsKey(key))
                {
                    r = d.Remove(key);
                    if (key == my_max_key) my_max_key = this.getMaxKey();
                }
            }
            return r;
        }
 
        public bool clear()
        {
            d.Clear();
            my_max_key = nil;
            return true;
        }
 
        public bool removeFirst()
        {
            int key = this.getFirstKey();
            return this.remove(key);
        }
 
        public bool removeLast()
        {
            int key = this.getLastKey();
            return this.remove(key);
        }
 
        public bool pop_back()
        {
            return this.removeLast();
        }
 
        public List<int> getKeyList()
        {
            return d.Keys.ToList();
        }
        public List<int> keys()
        {
            return d.Keys.ToList();
        }
 
        public List<T> getValueList()
        {
            return d.Values.ToList();
        }
 
        public List<T> list()
        {
            return d.Values.ToList();
        }
 
        public List<T> values()
        {
            return d.Values.ToList();
        }
 
        public IEnumerator GetEnumerator()
        {
            List<T> list = this.d.Values.ToList();
            foreach (T item in list)
            {
                yield return item;
            }
        }
 
        private int getLastKey()
        {
            List<int> l = this.getKeyList();
            if (l.Count == 0) return nil;
            return l.Last();
        }
 
        private int getFirstKey()
        {
            List<int> l = this.getKeyList();
            if (l.Count == 0) return nil;
            return l.First();
        }
 
        private int getMaxKey()
        {
            List<int> l = this.getKeyList();
            if (l.Count == 0) return nil;
            return l.Max();
        }
 
        public T first()
        {
            int key = this.getFirstKey();
            return this.get(key);
        }
 
        public T last()
        {
            int key = this.getLastKey();
            return this.get(key);
        }
 
        public T this[int key]
        {
            get
            {
                return this.getI(key);
            }
            set
            {
                this.setI(key, value);
            }
        }
 
        public T this[string key]
        {
            get
            {
                return this.getS(key);
            }
            set
            {
                this.setS(key, value);
            }
        }
 
 
        private T get(int key)//HashCode
        {
            T t = default(T);
            if (d.ContainsKey(key)) t = d[key];
            return t;
        }
 
        private T getI(int key)
        {
            int Hkey = this.isIntAutoIndexed ? key : key.ToString().GetHashCode();
            return this.get(Hkey);
        }
 
        private T getS(string key)
        {
            int Hkey = key.ToString().GetHashCode();
            return this.get(Hkey);
        }
 
        private void set(int key, T value)//HashCode, value
        {
            if (d.ContainsKey(key))
                d[key] = value;
            else
                this.insert(key, value);
        }
 
        private void setI(int key, T value)
        {
            int Hkey = this.isIndexType_Int() ? key : key.ToString().GetHashCode();
            this.set(Hkey, value);
        }
 
        private void setS(string key, T value)
        {
            int Hkey = key.GetHashCode();
            this.set(Hkey, value);
        }
 
    }//end class
 
}//end namespace
 
//Now, how we can use this class:
 
namespace MyNamespace
{
	class Edge
	{
		public int target;
		public int input;
		public double probability;
 
		public Edge(int target, int input, double probability)
		{
			this.target = target;
			this.input = input;
			this.probability = probability;
		}
	}
 
	class Edges : CAssocArray<Edge>
	{
 
		public Edge getClassWithMaxProbability()
		{
			double max_prob = 0.0; int max_idx = 0;
			int n = this.size();
			Edge e = new Edge();
			if (n == 0)
			{
				return e;
			}
			foreach (int i in this.getKeyList())
			{
				Edge ei = this[i];
				if (max_prob < ei.probability)
				{
					max_prob = ei.probability;
					max_idx = ei.target;
					e = ei;
				}
			}
			return e;
		}
	}
 
	class Node
	{
		public double probability;
		public Edges edges;
 
		public Node(double probability)
		{
			this.probability = probability;
			this.edges = new Edges();
		}
	}
 
	class Nodes : CAssocArray<Node>
	{
		public Nodes()
		{
			//do something
		}
	}
 
	class Program{
 
		static void Main(string[] args)
		{
			Nodes nodes = new Nodes();
			Node node0 = new Node(1.0);
			Node node1 = new Node(0.0);
			Node node2 = new Node(0.0);
			Node node3 = new Node(0.0);
			nodes.insert(node0);
			nodes[1] = node1;
			nodes.insert(node2);
			nodes[3] = node3;
 
			node0.edges.insert(new Edge(1, 11, 0.5));
			node0.edges.insert(new Edge(2, 12, 0.5));
 
 
			node1.edges[2] = new Edge(2, 12, 0.25);
			node1.edges[3] = new Edge(3, 13, 0.75);
 
			node2.edges[1] = new Edge(1, 11, 0.75);
			node2.edges[3] = new Edge(3, 13, 0.25);
 
			node3.edges[0] = new Edge(0, 10, 1.0);
 
			nodes[0].probability -= 0.25;
			nodes[1].probability += 0.25;
 
			nodes[0].edges[0].probability -= 0.1;
			nodes[0].edges[1].probability += 0.1;
 
			nodes[3].edges[0].probability = 0.5;
			nodes[3].edges[1] = new Edge(1, 11, 0.5);
 
			foreach(int i in nodes.getKeyList())
			{
				Node node = nodes[i];
				foreach(int j in node.edges.getKeyList())
				{
					Edge edge = node.edges[j];
					//do something
				}
			}
 
		}
 
	}
 
}//end namespace