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;

namespace DataPerformer
{
    public class DataPerformerStrategy : IDataPerformerStrategy, IStep
    {

        protected ArrayList components = new ArrayList();
        protected ArrayList objects = new ArrayList();
        protected ArrayList arrows = new ArrayList();
        protected ArrayList updatable = new ArrayList();
        protected int step;
        protected ArrayList dynamical = new ArrayList();
        protected ArrayList measurements = new ArrayList();
        protected double time;
        static private DataPerformerStrategy strategy;


        public DataPerformerStrategy()
        {

        }

        #region IDataPerformerStrategy Members


        /// <summary>
        /// Updates all elements
        /// </summary>
        public virtual void UpdateAll(IDesktop d)
        {
            foreach (IUpdatableObject up in updatable)
            {
                up.UpdateObject();
            }
        }


        /// <summary>
        /// Starts all desktop elements
        /// </summary>
        public virtual void StartAll(IDesktop d)
        {
            ICollection components = d.AllComponents;
            foreach (INamedComponent c in components)
            {
                if (c is IObjectLabel)
                {
                    IObjectLabel l = c as IObjectLabel;
                    if (!(l.Object is IStarted))
                    {
                        continue;
                    }
                    IStarted s = l.Object as IStarted;
                    s.Start();
                    continue;
                }
                if (c is IArrowLabel)
                {
                    IArrowLabel l = c as IArrowLabel;
                    if (!(l.Arrow is IStarted))
                    {
                        continue;
                    }
                    IStarted s = l.Arrow as IStarted;
                    s.Start();
                    continue;
                }
            }

        }

        public virtual void PrepareAll(IDesktop d)
        {
            ClearAll();
            prepareAll(d);
            updatable.Clear();
            foreach (INamedComponent c in components)
            {
                object o = null;
                if (c is IObjectLabel)
                {
                    IObjectLabel l = c as IObjectLabel;
                    o = l.Object;
                }
                else if (c is IArrowLabel)
                {
                    IArrowLabel l = c as IArrowLabel;
                    o = l.Arrow;
                }
                if (o == null)
                {
                    continue;
                }
                if (o is IDynamical)
                {
                    continue;
                }
                if (!(o is IUpdatableObject))
                {
                    continue;
                }
                IUpdatableObject up = o as IUpdatableObject;
                if (up.ShouldUpdate)
                {
                    updatable.Add(up);
                }
            }
            foreach (INamedComponent comp in components)
            {
                IDynamical dyn = null;
                if (comp is IObjectLabel)
                {
                    IObjectLabel label = comp as IObjectLabel;
                    ICategoryObject obj = label.Object;
                    if (!(obj is IDynamical))
                    {
                        continue;
                    }
                    dyn = obj as IDynamical;
                }
                else if (comp is IArrowLabel)
                {
                    IArrowLabel label = comp as IArrowLabel;
                    ICategoryArrow arr = label.Arrow;
                    if (!(arr is IDynamical))
                    {
                        continue;
                    }
                    dyn = arr as IDynamical;
                }
                dynamical.Add(dyn);
            }
            foreach (INamedComponent comp in components)
            {
                if (!(comp is IObjectLabel))
                {
                    continue;
                }
                IObjectLabel l = comp as IObjectLabel;
                object ob = l.Object;
                if (!(ob is IMeasurements))
                {
                    continue;
                }
                IMeasurements m = ob as IMeasurements;
                measurements.Add(m);
            }
        }


        /// <summary>
        /// Clears all components
        /// </summary>
        public void ClearAll()
        {
            if (components != null)
            {
                components.Clear();
            }
            if (objects != null)
            {
                objects.Clear();
            }
            if (arrows != null)
            {
                arrows.Clear();
            }
            updatable.Clear();
            dynamical.Clear();
            measurements.Clear();
            GC.Collect();
        }

        public double Time
        {
            get
            {
                return time;
            }
            set
            {
                time = value;
                foreach (IDynamical dyn in dynamical)
                {
                    dyn.Time = value;
                }
                UpdateAll(null);
                ResetUpdatedMeasurements();
            }
        }



        #endregion


        #region IStep Members

        public int Step
        {
            get
            {
                return step;
            }
            set
            {
                step = value;
                foreach (object c in components)
                {
                    object o = null;
                    if (c is IObjectLabel)
                    {
                        IObjectLabel l = c as IObjectLabel;
                        o = l.Object;

                    }
                    if (c is IArrowLabel)
                    {
                        IArrowLabel l = c as IArrowLabel;
                        o = l.Arrow;
                    }
                    if (!(o is IStep))
                    {
                        continue;
                    }
                    IStep s = o as IStep;
                    s.Step = value;
                }
            }
        }

        public void ResetUpdatedMeasurements()
        {
            foreach (IMeasurements m in measurements)
            {
                m.IsUpdated = false;
            }
        }

        #endregion

        #region Specific Members


        public static DataPerformerStrategy Object
        {
            get
            {
                return strategy;
            }
            set
            {
                strategy = value;
            }
        }




        public ICollection Components
        {
            get
            {
                return components;
            }
        }

        private void prepareAll(IDesktop d)
        {
            ICollection comps = d.Components;
            foreach (INamedComponent c in comps)
            {
                components.Add(c);
                if (c is IArrowLabel)
                {
                    arrows.Add(c);
                    continue;
                }
                if (!(c is IObjectLabel))
                {
                    continue;
                }
                objects.Add(c);
                IObjectLabel l = c as IObjectLabel;
                if (l.Object is ObjectContainer)
                {
                    ObjectContainer cont = l.Object as ObjectContainer;
                    prepareAll(cont.Desktop);
                }
            }
        }


        #endregion

    }
}