---

/root/src/subsynth/syn/Builder/ModuleFactory.h

Go to the documentation of this file.

/****************** <SYN heading BEGIN do not edit this line> *****************
 *
 * subsynth - modular audio synthesizer
 * subsynth is (C) Copyright 2001-2002 by Kevin Meinert
 *
 * Original Author: Kevin Meinert
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: ModuleFactory.h,v $
 * Date modified: $Date: 2002/04/15 01:55:54 $
 * Version:       $Revision: 1.3 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/

#ifndef SYNTHMODULE_FACTORY
#define SYNTHMODULE_FACTORY

#include <string>
#include <map>
#include <syn/Core/Module.h>
#include <syn/Util/Singleton.h>
#include <syn/Module/DummyOutputModule.h>
#include <syn/Module/FilterModule.h>
#include <syn/Module/IStreamModule.h>
#include <syn/Module/MixerModule.h>
#include <syn/Module/OpenALOutputModule.h>
#include <syn/Module/OperatorModule.h>
#include <syn/Module/OscModule.h>
#include <syn/Module/SplitterModule.h>
#include <syn/Module/WaveTableOscModule.h>
#include <syn/Module/InstrumentModule.h>

#include <syn/xmlpp/xmlpp.h>

namespace syn
{
   class ModuleFactory : syn::Singleton<ModuleFactory>
   {
   public:
      ModuleFactory()
      {
         // just some defaults, in the future these may be dynamically loaded.
         // if you're extending subsynth with your own modules, 
         // you have the option to edit this (bad), or to call reg 
         // externally from your own application (good).

         // modules
         this->reg( "Sink", DummyOutputModule() );
         this->reg( "Filter", FilterModule() );
         this->reg( "IStream", IStreamModule() );
         this->reg( "Mixer", MixerModule() );
         this->reg( "OpenALSink", OpenALOutputModule() );
         this->reg( "Splitter", SplitterModule() );
         this->reg( "WaveTableOsc", WaveTableOscModule() );

         // operators
         this->reg( "Add", AddModule() );
         this->reg( "Mult", MultModule() );
         this->reg( "Copy", CopyModule() );

         // osc
         this->reg( "TriangleOsc", TriangleOscModule() );
         this->reg( "WhiteNoiseOsc", WhiteNoiseOscModule() );
         this->reg( "PinkNoiseOsc", PinkNoiseOscModule() );
         this->reg( "SineOsc", SineOscModule() );
         this->reg( "SquareOsc", SquareOscModule() );
         this->reg( "AdsrOsc", AdsrOscModule() );
      }

      void reg( std::string typeName, const Module& proto )
      {
         mPrototypes[typeName] = proto.clone();
      }

      void unreg( std::string typeName )
      {
         mPrototypes.erase( typeName );
      }

      bool create( std::string typeName, Module* &newModule )
      {
         if (mPrototypes.count( typeName ) > 0)
         {
            newModule = mPrototypes[typeName]->clone();
            return true;
         }
         return false;
      }

   private:
      // each module prototype knows how to clone itself
      std::map<std::string, Module*> mPrototypes;
   };

} // end namespace

#endif

---