NParallel, A Small Parallel Execution Library

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting.Messaging;
using System.Diagnostics;

namespace NParallel.Core
{
    public delegate T TDelegate<T>();
    public delegate void TResultDel<T>(T result);
    public delegate void DelegateVoid();

    public enum NMarshal
    {
        Manual,
        Auto
    }
    
    public abstract class INResult 
    {
        protected bool done;
        protected IAsyncResult ar;
        protected NMarshal marshal = NMarshal.Auto;

        public NMarshal Marshal 
        {
            get 
            {
                return marshal;
            }
            set 
            {
                marshal = value;
            }
        }

        public INResult(IAsyncResult par) 
        {
            ar = par;
        }

        public bool Done
        {
            get
            {
                return done;
            }
            set
            {
                done = value;
            }
        }

        public bool IsDone()
        {
            return ar.IsCompleted;
        }

        public IAsyncResult Ar
        {
            get
            {
                return ar;
            }
            set
            {
                ar = value;
            }
        }

        public void AutoCallback(IAsyncResult tar) 
        {
            if (marshal == NMarshal.Auto && ar == tar)
            {
                Complete();
                DoCallback();
            }
        }

        public abstract void Complete();
        public abstract object GetCaller();
        public abstract void DoCallback();
    }

    public class NResult<T> : INResult
    {
        T val;
        TDelegate<T> caller = null;
        TResultDel<T> callback = null;
        
        public NResult(IAsyncResult ar , TDelegate<T> pcaller , TResultDel<T> pcallback)
            : base(ar)
        {
            caller = pcaller;
            callback = pcallback;
        }

        public NResult(TDelegate<T> pcaller, TResultDel<T> pcallback)
            : base(null)
        {
            caller = pcaller;
            callback = pcallback;
        }

        public TDelegate<T> Caller
        {
            set
            {
                caller = value;
            }
        }

        public TResultDel<T> Callback
        {
            set
            {
                callback = value;
            }
        }

        public T Value 
        {
            get 
            {
                if (! done)
                {
                    Wait();
                }
                
                return val;
            }
            set 
            {
                val = value;
            }
        }

        public T Wait(/* int milli-sec-to-wait */) 
        {
            lock (this)
            {
                if (done)
                {
                    return val;
                }

                if (ar == null)
                {
                    throw new ArgumentException("The result waited on is NULL");
                }

                object obj = ((AsyncResult)ar).AsyncDelegate;
                Debug.Assert(obj == caller);

                val = caller.EndInvoke(ar);
                //val = (T)Reflection.InvokeMethod(obj, "EndInvoke", ar);
                done = true;
                return val;
            }
        }

        public override void Complete() 
        {
            Wait();
        }

        public override object GetCaller() 
        {
            return caller;
        }

        public override void DoCallback() 
        {
            if (callback != null)
            {
                callback(Value);    
            }
            
        }
    }

    public class NResult : INResult
    {
        DelegateVoid caller = null;
        DelegateVoid callback = null;

        public NResult(IAsyncResult ar, DelegateVoid pcaller, DelegateVoid pcallback) 
            : base(ar)
        {
            caller = pcaller;
            callback = pcallback;
        }

        public NResult(DelegateVoid pcaller, DelegateVoid pcallback)
            : base(null)
        {
            caller = pcaller;
            callback = pcallback;
        }

        public DelegateVoid Caller
        {
            set
            {
                caller = value;
            }
        }

        public DelegateVoid Callback
        {
            set
            {
                callback = value;
            }
        }

        public void Wait(/* int milli-sec-to-wait */)
        {
            lock (this)
            {
                if (done)
                {
                    return;
                }

                if (ar == null)
                {
                    throw new ArgumentException("The result waited on is NULL");
                }

                object obj = ((AsyncResult)ar).AsyncDelegate;

                Debug.Assert(obj == caller);

                caller.EndInvoke(ar);
                done = true;
            }
        }

        public override void Complete()
        {
            Wait();
        }

        public override object GetCaller()
        {
            return caller;
        }

        public override void DoCallback()
        {
            if (callback != null)
            {
                callback();
            }
        }
    }
}