Universal Framework for Science and Engineering - Part 4: Space elevator

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;

using CategoryTheory;
using DiagramUI;
using MathGraph;


namespace DataPerformer
{
    /// <summary>
    /// Consumer of time
    /// </summary>
    public interface ITimeMeasureConsumer
    {
        /// <summary>
        /// Time measure
        /// </summary>
        IMeasure Time
        {
            set;
        }
    }

    /// <summary>
    /// Provider of time
    /// </summary>
    public interface ITimeMeasureProvider
    {
        /// <summary>
        /// Time measure
        /// </summary>
        IMeasure Time
        {
            get;
        }
    }

    /// <summary>
    /// Performer of all operations of time measure
    /// </summary>
    public class TimeMeasurePerformer
    {
        static private readonly string illegal = "Illegal sequence of time providers";

        static IMeasure timeMeasure = new MeasureDerivation(a, new MeasureParameter(GetTime), new MeasureParameter(Unity), "Time");

        static private readonly Double a = 0;

        static private void check(DataLink l)
        {
            object o = l.Object;
            if (o != null)
            {
                if (o is INamedComponent)
                {
                    INamedComponent nc = o as INamedComponent;
                    IDesktop d = nc.Desktop;
                    Check(d);
                }
            }
        }

        static public void SetLinkChecker()
        {
            CheckDataLink ch = new CheckDataLink(check);
            DataLink.Checker = ch;
        }

        static public void Check(IDesktop desktop)
        {
            IDesktop d = desktop.Root;
            CheckObject ch = new CheckObject(checkLink);
            List<IObjectLabel> objects;
            List<IArrowLabel> arrows;
            PureDesktopPeer.GetFullList(d, out objects, out arrows);
            Digraph graph = PureDesktop.CreateDigraph(objects, arrows, null, ch);
            ArrayList loops = graph.Loops;
            foreach (DigraphLoop loop in loops)
            {
                check(loop);
            }
        }

        static public void SetProvider(IDataConsumer consumer)
        {
            SetProvider(consumer, null);
        }

        static public void SetProvider(IDataConsumer consumer, ITimeMeasureProvider provider)
        {
            ITimeMeasureProvider p = provider;
            if (consumer is ITimeMeasureConsumer)
            {
                ITimeMeasureConsumer cons = consumer as ITimeMeasureConsumer;
                if (provider == null)
                {
                    cons.Time = timeMeasure;
                }
                else
                {
                    cons.Time = provider.Time;
                }
            }
            if (consumer is ITimeMeasureProvider)
            {
                p = consumer as ITimeMeasureProvider;
            }
            for (int i = 0; i < consumer.Count; i++)
            {
                IMeasurements m = consumer[i];
                if (m is IDataConsumer)
                {
                    IDataConsumer cons = m as IDataConsumer;
                    SetProvider(cons, p);
                    continue;
                }
                if (m is ITimeMeasureConsumer)
                {
                    ITimeMeasureConsumer cons = m as ITimeMeasureConsumer;
                    if (p == null)
                    {
                        cons.Time = timeMeasure;
                    }
                    else
                    {
                        cons.Time = p.Time;
                    }
                }
            }
        }


        static private void check(DigraphLoop loop)
        {
            ITimeMeasureProvider[] p = new ITimeMeasureProvider[] { getProvider(loop[0]), getProvider(loop[1]) };
            if (p[0] == null | p[1] == null)
            {
                return;
            }
            if (p[0] != p[1])
            {
                throw new Exception(illegal);
            }
        }

        static private ITimeMeasureProvider getProvider(DigraphPath path)
        {
            ITimeMeasureProvider p = null;
            for (int i = 0; i < path.Count - 1; i++)
            {
                ICategoryObject ob = path[i].CategoryObject;
                if (ob is ITimeMeasureProvider)
                {
                    p = ob as ITimeMeasureProvider;
                }
            }
            return p;
        }

        static private bool checkLink(object obj)
        {
            return obj is DataLink;
        }

        /// <summary>
        /// The unity
        /// </summary>
        /// <returns>Unity</returns>
        static private object Unity()
        {
            return (double)1;
        }



        /// <summary>
        /// Measurement of time
        /// </summary>
        static public IMeasure TimeMeasure
        {
            get
            {
                return timeMeasure;
            }
        }

        /// <summary>
        /// Gets time
        /// </summary>
        /// <returns>The time</returns>
        static private object GetTime()
        {
            return DataPerformerStrategy.Object.Time;
        }

  

    }
}