Grandiose projects 5. Audio support

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


using CategoryTheory;
using DiagramUI;
using DiagramUI.Labels;
using DiagramUI.Interfaces;


using DataPerformer.Interfaces;


namespace DataPerformer
{
    /// <summary>
    /// Wrapper of measurements
    /// </summary>
    public class MeasurementsWrapper : IMeasurements, 
         IAssociatedObject, IStarted
    {

        #region Fields

        private IMeasure[] measurements;

        private IMeasurements[] mea;

        private bool isUpdated;

        IAssociatedObject associated;


        #endregion

        #region Ctor

        private MeasurementsWrapper(IAssociatedObject associated)
        {
            this.associated = associated;
        }

        #endregion

        #region IMeasurements Members

        int IMeasurements.Count
        {
            get { return measurements.Length; }
        }

        IMeasure IMeasurements.this[int number]
        {
            get { return measurements[number]; }
        }

        void IMeasurements.UpdateMeasurements()
        {
            foreach (IMeasurements m in mea)
            {
                m.UpdateMeasurements();
            }
        }

        bool IMeasurements.IsUpdated
        {
            get
            {
                return isUpdated;
            }
            set
            {
                isUpdated = value;
            }
        }

        #endregion

        #region IAssociatedObject Members

        object IAssociatedObject.Object
        {
            get
            {
                return associated.Object;
            }
            set
            {
            }
        }

        #endregion

        #region IStarted Members

        void IStarted.Start(double time)
        {
            foreach (IMeasurements m in mea)
            {
                if (m is IStarted)
                {
                    IStarted st = m as IStarted;
                    st.Start(time);
                }
            }
        }

        #endregion


        #region Public Members

        /// <summary>
        /// Count of measurements
        /// </summary>
        public int Count
        {
            get
            {
                return mea.Length;
            }
        }

        /// <summary>
        /// Access to measurements
        /// </summary>
        /// <param name="number">Number of measurements</param>
        /// <returns>The measurements</returns>
        public IMeasurements this[int number]
        {
            get
            {
                return mea[number];
            }
        }

        /// <summary>
        /// Creates measurements
        /// </summary>
        /// <param name="obj">Associated object</param>
        /// <returns>Measurements</returns>
        static internal IMeasurements Create(IAssociatedObject obj)
        {
            return Get(null, obj, obj);
        }

        #endregion

        #region Private Members


        private static IMeasurements Get(IMeasurements master,
           IAssociatedObject root, IAssociatedObject obj)
        {
            IMeasurements res = null;
            if (obj is IMeasurements)
            {
                res = obj as IMeasurements;
            }
            res = Create(root, master, res);
            if (obj is IChildrenObject)
            {
                IChildrenObject co = obj as IChildrenObject;
                IAssociatedObject[] ch = co.Children;
                foreach (IAssociatedObject ao in ch)
                {
                    res = Get(res, root, ao);
                }
            }
            return res;
        }


        private static IMeasurements Create(IAssociatedObject root,
            IMeasurements master,
            IMeasurements slave)
        {
            if (master == null)
            {
                return slave;
            }
            if (slave == null)
            {
                return master;
            }
            if (master is MeasurementsWrapper)
            {
                MeasurementsWrapper mw = master as MeasurementsWrapper;
                mw.Add(slave);
                return mw;
            }
            MeasurementsWrapper wrapper = new MeasurementsWrapper(root);
            wrapper.Add(master);
            wrapper.Add(slave);
            return wrapper;
        }

        private void Add(IMeasurements measurements)
        {
            List<IMeasurements> l = new List<IMeasurements>();
            if (mea != null)
            {
                l.AddRange(mea);
            }
            l.Add(measurements);
            mea = l.ToArray();
            List<IMeasure> m = new List<IMeasure>();
            if (this.measurements != null)
            {
                m.AddRange(this.measurements);
            }
            int n = measurements.Count;
            for (int i = 0; i < n; i++)
            {
                m.Add(measurements[i]);
            }
            this.measurements = m.ToArray();
        }

        #endregion


    }
}