Grandiose projects 5. Audio support

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

using DiagramUI;

using DataPerformer.Interfaces;
using DataPerformer.SeriesTypes;

namespace DataPerformer
{
    /// <summary>
    /// Extension utilites
    /// </summary>
    public static class StaticExtensionAdvanced
    {
        /// <summary>
        /// Saves series to stream
        /// </summary>
        /// <param name="series">Series to save</param>
        /// <param name="stream">Stream for saving</param>
        static public void Save(this Series series, Stream stream)
        {
            Series s = new Series();
            s.CopyFrom(series);
            s.Comments = series.Comments;
            BinaryFormatter form = new BinaryFormatter();
            form.Serialize(stream, s);
        }

        /// <summary>
        /// Saves series to file
        /// </summary>
        /// <param name="series">Series</param>
        /// <param name="filename">File name</param>
        static public void Save(this Series series, string filename)
        {
            Stream str = File.OpenWrite(filename);
            series.Save(str);
            str.Close();
        }

        /// <summary>
        /// Loads series from stream
        /// </summary>
        /// <param name="series">The series</param>
        /// <param name="stream">Stream for load</param>
        static public void Load(this Series series, Stream stream)
        {
            BinaryFormatter form = new BinaryFormatter();
            Series s = form.Deserialize(stream) as Series;
            series.CopyFrom(s);
            series.Comments = s.Comments;
        }

        /// <summary>
        /// Loads series from file
        /// </summary>
        /// <param name="series">Series</param>
        /// <param name="filename">File name</param>
        static public void Load(this Series series, string filename)
        {
            Stream str = File.OpenRead(filename);
            Load(series, str);
            str.Close();
        }

        /// <summary>
        /// Creates measurements
        /// </summary>
        /// <param name="consumer">Data consumer</param>
        /// <param name="argument">Argument</param>
        /// <param name="values">Names of values</param>
        /// <param name="series">series</param>
        /// <param name="functions">functions</param>
        /// <returns>Mesurements dictionary</returns>
        public static Dictionary<string, object> CreateMeasurements(this IDataConsumer consumer, string argument, string[] values, out ParametrizedSeries[] series,
            out Dictionary<DoubleArrayFunction, IMeasure[]> functions)
        {
            Double a = 0;
            functions = new Dictionary<DoubleArrayFunction, IMeasure[]>();
            series = null;
            if (argument == null | values == null)
            {
                return null;
            }
            IMeasure arg = null;
            if (argument.Equals("Time"))
            {
                arg = DataPerformer.StaticExtensionDataPerformerBase.Factory.TimeProvider.TimeMeasure;
            }
            else
            {
                arg = consumer.FindMeasure(argument, false);
            }
            Dictionary<string, object> d = new Dictionary<string, object>();
            List<ParametrizedSeries> m = new List<ParametrizedSeries>();
            foreach (string key in values)
            {
                object o = null;
                IMeasure val = consumer.FindMeasure(key, false);
                object t = val.Type;
                if (t.Equals(a))
                {

                    ParametrizedSeries ps = new ParametrizedSeries(DataPerformer.Measures.MeasureWrapper.CreateValueHolder(arg),
                        DataPerformer.Measures.MeasureWrapper.CreateValueHolder(val));
                    m.Add(ps);
                    o = ps;
                }
                else
                {
                    DoubleArrayFunction f = new DoubleArrayFunction(t);
                    functions[f] = new IMeasure[] { arg, val };
                    o = f;
                }
                d[key] = o;
            }
            series = m.ToArray();
            Type type = consumer.GetType();
            System.Reflection.MethodInfo mi = type.GetMethod("Prepare", new Type[0]);
            if (mi != null)
            {
                mi.Invoke(consumer, new object[0]);
            }
            return d;
        }


        /// <summary>
        /// Performs action with fixed step
        /// </summary>
        /// <param name="consumer">Data consumer</param>
        /// <param name="start">Start time</param>
        /// <param name="start">Start time</param>
        /// <param name="step">Step</param>
        /// <param name="count">Count of steps</param>
        /// <param name="argument">Argument</param>
        /// <param name="values">Values</param>
        /// <param name="series">Series</param>
        /// <param name="functions">Functions</param>
        /// <param name="stop">Stop function</param>
        /// <returns>Result of simulation</returns>
        public static Dictionary<string, object> PerformFixed(this IDataConsumer consumer, double start, double step, int count, string argument, string[] values,
             out ParametrizedSeries[] series,
            out Dictionary<DoubleArrayFunction, IMeasure[]> functions)
        {
            try
            {
                series = null;
                functions = null;
                Dictionary<string, object> dic = consumer.CreateMeasurements(argument, values, out series, out functions);
                if (dic == null)
                {
                    return null;
                }
                PerformFixed(consumer, start, step, count, argument, values, series, functions);
                return dic;
            }

            catch (Exception ex)
            {
                ex.ShowError(10);
                consumer.Throw(ex);
            }
            series = null;
            functions = null;
            return null;
        }

        /// <summary>
        /// Performs operation with fixed step
        /// </summary>
        /// <param name="consumer">Data consumer</param>
        /// <param name="start">Start time</param>
        /// <param name="step">Step</param>
        /// <param name="count">Count of steps</param>
        /// <param name="argument">Argument</param>
        /// <param name="values">Values</param>
        /// <returns>Dictionary of performed result</returns>
        public static Dictionary<string, object> PerformFixed(this IDataConsumer consumer, double start, double step, int count,
            string argument, string[] values)
        {
            ParametrizedSeries[] series = null;
            Dictionary<DoubleArrayFunction, IMeasure[]> functions = null;
            return consumer.PerformFixed(start, step, count, argument, values, out series, out functions);
        }
        /// <summary>
        /// Gets series
        /// </summary>
        /// <param name="consumer">Data consumer</param>
        /// <param name="start">Start</param>
        /// <param name="step">Step</param>
        /// <param name="count">Count of steps</param>
        /// <param name="argument">Argument</param>
        /// <param name="values">Values</param>
        /// <returns>Dictionary of series</returns>
        public static Dictionary<string, DataPerformer.Basic.Series> GetSeries(this IDataConsumer consumer, double start, double step, int count,
             string argument, string[] values)
        {
            Dictionary<string, DataPerformer.Basic.Series> dic = new Dictionary<string, Basic.Series>();
            Dictionary<string, object> d = consumer.PerformFixed(start, step, count, argument, values);
            foreach (string key in d.Keys)
            {
                ParametrizedSeries s = d[key] as ParametrizedSeries;
                DataPerformer.Basic.Series ser = new DataPerformer.Basic.Series();
                ser.CopyFrom(s);
                dic[key] = ser;
            }
            return dic;
        }


        private static void  PerformFixed(IDataConsumer consumer, double start, double step, int count, string argument, string[] values,
       ParametrizedSeries[] series,
      Dictionary<DoubleArrayFunction, IMeasure[]> functions)
        {
            consumer.PerformFixed(start, step, count, DataPerformer.StaticExtensionDataPerformerBase.Factory.TimeProvider,
                DifferentialEquationProcessor.Processor, (consumer as CategoryTheory.IAssociatedObject).GetRootDesktop(), 0, delegate()
                {
                    foreach (ParametrizedSeries s in series)
                    {
                        s.Step();
                    }
                    foreach (DoubleArrayFunction f in functions.Keys)
                    {
                        IMeasure[] mm = functions[f];
                        double xx = (double)mm[0].Parameter();
                        f[xx] = mm[1].Parameter();
                    }
                }
            );
        }


    }
}