C# Synth Toolkit - Part I

#region License

/* Copyright (c) 2007 Leslie Sanford
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy 
 * of this software and associated documentation files (the "Software"), to 
 * deal in the Software without restriction, including without limitation the 
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
 * sell copies of the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software. 
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 * THE SOFTWARE.
 */

#endregion

#region Contact

/*
 * Leslie Sanford
 * Email: jabberdabber@hotmail.com
 */

#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;

namespace Sanford.Multimedia.Synth
{
    /// <summary>
    /// Represents a collection of Programs.
    /// </summary>
    internal sealed class Bank : IEnumerable<Program>
    {
        #region Bank Members

        #region Fields

        // Use to identify Bank files.
        private const string BankFileHeader = "Synth Bank File";

        // The Programs belonging to the Bank.
        private List<Program> programs = new List<Program>();

        // The name of the synthesizer the Bank belongs to.
        private string synthName;

        // The number of parameters in each Program.
        private int parameterCount;

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the Bank class with the specified 
        /// synthesizer name and parameter count.
        /// </summary>
        /// <param name="synthName">
        /// The name of the synthesizer to which the Bank belongs.
        /// </param>
        /// <param name="parameterCount">
        /// The number of parameters used by the Programs in the Bank.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// synthName is null.
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// parameterCount is less than zero.
        /// </exception>
        public Bank(string synthName, int parameterCount)
        {
            #region Require

            if(synthName == null)
            {
                throw new ArgumentNullException("synthName");
            }
            else if(parameterCount < 0)
            {
                throw new ArgumentOutOfRangeException("parameterCount");
            }

            #endregion

            this.synthName = synthName;
            this.parameterCount = parameterCount;

            // Create Programs.
            for(int i = 0; i < 128; i++)
            {
                programs.Add(new Program(synthName, parameterCount));
            }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Loads data into Bank using the specified file name.
        /// </summary>
        /// <param name="fileName">
        /// The name of the file from which to load data.
        /// </param>
        /// <exception cref="FileException">
        /// The file is not the right type or the number of parameters is not correct.
        /// </exception>
        public void Load(string fileName)
        {
            using(FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                BinaryReader reader = new BinaryReader(stream);

                // If this isn't a bank file.
                if(reader.ReadString() != BankFileHeader)
                {
                    reader.Close();

                    throw new FileException("Wrong type of file.");
                }

                // If the synthesizer name does not match.
                if(reader.ReadString() != synthName)
                {
                    reader.Close();
                    
                    throw new FileException("Wrong type of file.");
                }

                int p = reader.ReadInt32();

                // Choose the smaller number of parameters. This gives us some
                // flexibility with changing the number of parameters, though
                // mismatching parameters to values is possible.
                p = (p < parameterCount ? p : parameterCount);               

                List<Program> newPrograms = new List<Program>();

                // Read programs from file.
                for(int i = 0; i < ProgramCount; i++)
                {
                    newPrograms.Add(new Program(synthName, reader.ReadString(), parameterCount));

                    // Read parameter data into Program.
                    for(int n = 0; n < p; n++)
                    {
                        newPrograms[i][n] = reader.ReadSingle();
                    }
                }

                // Replace old Programs with the new ones.
                programs = newPrograms;

                reader.Close();
            }
        }

        /// <summary>
        /// Saves bank data to file using the specified file name.
        /// </summary>
        /// <param name="fileName">
        /// The file name to use for saving program data.
        /// </param>
        public void Save(string fileName)
        {
            using(FileStream stream = new FileStream(fileName, FileMode.Create))
            {
                BinaryWriter writer = new BinaryWriter(stream);

                writer.Write(BankFileHeader);
                writer.Write(synthName);                
                writer.Write(parameterCount);

                foreach(Program program in programs)
                {
                    writer.Write(program.Name);

                    for(int i = 0; i < parameterCount; i++)
                    {
                        writer.Write(program[i]);
                    }
                }

                writer.Close();
            }
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets the Program at the specified zero-based index.
        /// </summary>
        /// <param name="index">
        /// The zero-based index of the Program to get.
        /// </param>
        /// <returns>
        /// The Program at the specified zero-based index.
        /// </returns>
        /// <exception cref="IndexOutOfRangeException">
        /// index is less than zero or greater than or equal to Count.
        /// </exception>
        public Program this[int index]
        {
            get
            {
                #region Require

                if(index < 0 || index >= ProgramCount)
                {
                    throw new ArgumentOutOfRangeException("index");
                }

                #endregion

                return programs[index];
            }
        }

        /// <summary>
        /// Gets the number of Programs.
        /// </summary>
        public int ProgramCount
        {
            get
            {
                return programs.Count;
            }
        }

        #endregion

        #endregion

        #region IEnumerable<Program> Members

        public IEnumerator<Program> GetEnumerator()
        {
            return programs.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return programs.GetEnumerator();
        }

        #endregion
    }
}