src/drivers/DeviceParameterFactory.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2014 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_DEVICE_PARAMETER_FACTORY_H__
#define __LS_DEVICE_PARAMETER_FACTORY_H__

#include <map>
#include <vector>

#include "../common/global.h"
#include "../common/optional.h"
#include "../common/Exception.h"
#include "DeviceParameter.h"

namespace LinuxSampler {

        class DeviceParameterFactory {
                public:
                        typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
                        
                        class InnerFactory {
                                public:
                                        InnerFactory(DeviceParameterFactory* pParent) { this->pParent = pParent; }
                                        virtual ~InnerFactory() {}
                                        virtual DeviceCreationParameter* Create(std::map<String,String> Parameters = StringMap()) = 0;
                                        virtual DeviceCreationParameter* Create(String val) = 0;
                                protected:
                                        DeviceParameterFactory* pParent;
                        };
                        
                        template <class Parameter_T>
                        class InnerFactoryTemplate : public InnerFactory {
                                public:
                                        InnerFactoryTemplate(DeviceParameterFactory* pParent) : InnerFactory(pParent) {}
                                        
                                        /// Create parameter with respective value in map or use its default value.
                                        virtual DeviceCreationParameter* Create(std::map<String,String> Parameters = StringMap()) {
                                                const String paramName = Parameter_T::Name();
                                                if (Parameters.count(paramName)) {
                                                        // parameter with this name was specified, so use that given value
                                                        return new Parameter_T(Parameters[paramName]);
                                                }
                                                // parameter value not given, use its default value ...
                                                // ... but first resolve its dependencies to other parameters
                                                Parameter_T param;
                                                std::map<String,DeviceCreationParameter*> dependencies = param.DependsAsParameters();
                                                std::map<String,String> dependencysParams;
                                                for (std::map<String,DeviceCreationParameter*>::iterator iter = dependencies.begin(); iter != dependencies.end(); iter++) {
                                                        if (Parameters.count(iter->first)) {
                                                                // value for this dependency parameter already given
                                                                dependencysParams[iter->first] = Parameters[iter->first];
                                                        } else {
                                                                // no value provided for this dependency parameter, use its default value
                                                                // (FIXME: no sanity check for cyclic dependencies here yet)
                                                                DeviceCreationParameter* pDependencyParam = pParent->Create(iter->first, Parameters);
                                                                if (pDependencyParam) {
                                                                        dependencysParams[iter->first] = pDependencyParam->Value();
                                                                        delete pDependencyParam;
                                                                }
                                                        }
                                                }
                                                // now that we resolved all dependencies, we can finally determine parameter's default value
                                                optional<String> defaultValue = param.Default(dependencysParams);
                                                return (defaultValue) ? new Parameter_T(*defaultValue) : new Parameter_T();
                                        }
                                        /// Create parameter with given value.
                                        virtual DeviceCreationParameter* Create(String val) { return new Parameter_T(val); }
                        };

                        template <class Parameter_T>
                        static void Register(DeviceParameterFactory* factory) {
                                factory->InnerFactories[Parameter_T::Name()] = new InnerFactoryTemplate<Parameter_T>(factory);
                        }

                        std::map<String,DeviceCreationParameter*> CreateAllParams ( std::map<String,String> Parameters );
                        std::map<String,DeviceCreationParameter*> CreateAllParams ();

                        DeviceCreationParameter* Create(String ParameterName, std::map<String,String> Parameters = StringMap()) throw (Exception);
                        DeviceCreationParameter* Create(String ParameterName, String val) throw (Exception);

                        ~DeviceParameterFactory();

                protected:
                        std::map<String, InnerFactory*> InnerFactories;
        };

} // namespace LinuxSampler

#endif // __LS_DEVICE_PARAMETER_FACTORY_H__
1	senkov	174	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	2505	* Copyright (C) 2005 - 2014 Christian Schoenebeck *
7	senkov	174	* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#ifndef __LS_DEVICE_PARAMETER_FACTORY_H__
25			#define __LS_DEVICE_PARAMETER_FACTORY_H__
26
27			#include <map>
28			#include <vector>
29
30			#include "../common/global.h"
31			#include "../common/optional.h"
32	schoenebeck	880	#include "../common/Exception.h"
33	senkov	174	#include "DeviceParameter.h"
34
35			namespace LinuxSampler {
36
37			class DeviceParameterFactory {
38			public:
39	schoenebeck	1049	typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
40
41	senkov	174	class InnerFactory {
42			public:
43	schoenebeck	1049	InnerFactory(DeviceParameterFactory* pParent) { this->pParent = pParent; }
44	schoenebeck	2505	virtual ~InnerFactory() {}
45	schoenebeck	1049	virtual DeviceCreationParameter* Create(std::map<String,String> Parameters = StringMap()) = 0;
46	senkov	174	virtual DeviceCreationParameter* Create(String val) = 0;
47	schoenebeck	1049	protected:
48			DeviceParameterFactory* pParent;
49	senkov	174	};
50
51			template <class Parameter_T>
52			class InnerFactoryTemplate : public InnerFactory {
53			public:
54	schoenebeck	1049	InnerFactoryTemplate(DeviceParameterFactory* pParent) : InnerFactory(pParent) {}
55
56			/// Create parameter with respective value in map or use its default value.
57			virtual DeviceCreationParameter* Create(std::map<String,String> Parameters = StringMap()) {
58			const String paramName = Parameter_T::Name();
59			if (Parameters.count(paramName)) {
60			// parameter with this name was specified, so use that given value
61			return new Parameter_T(Parameters[paramName]);
62			}
63			// parameter value not given, use its default value ...
64			// ... but first resolve its dependencies to other parameters
65			Parameter_T param;
66			std::map<String,DeviceCreationParameter*> dependencies = param.DependsAsParameters();
67			std::map<String,String> dependencysParams;
68			for (std::map<String,DeviceCreationParameter*>::iterator iter = dependencies.begin(); iter != dependencies.end(); iter++) {
69			if (Parameters.count(iter->first)) {
70			// value for this dependency parameter already given
71			dependencysParams[iter->first] = Parameters[iter->first];
72			} else {
73			// no value provided for this dependency parameter, use its default value
74			// (FIXME: no sanity check for cyclic dependencies here yet)
75			DeviceCreationParameter* pDependencyParam = pParent->Create(iter->first, Parameters);
76			if (pDependencyParam) {
77			dependencysParams[iter->first] = pDependencyParam->Value();
78			delete pDependencyParam;
79			}
80			}
81			}
82			// now that we resolved all dependencies, we can finally determine parameter's default value
83			optional<String> defaultValue = param.Default(dependencysParams);
84			return (defaultValue) ? new Parameter_T(*defaultValue) : new Parameter_T();
85			}
86			/// Create parameter with given value.
87	senkov	174	virtual DeviceCreationParameter* Create(String val) { return new Parameter_T(val); }
88			};
89
90			template <class Parameter_T>
91			static void Register(DeviceParameterFactory* factory) {
92	schoenebeck	1049	factory->InnerFactories[Parameter_T::Name()] = new InnerFactoryTemplate<Parameter_T>(factory);
93	senkov	174	}
94
95			std::map<String,DeviceCreationParameter*> CreateAllParams ( std::map<String,String> Parameters );
96			std::map<String,DeviceCreationParameter*> CreateAllParams ();
97
98	schoenebeck	1049	DeviceCreationParameter* Create(String ParameterName, std::map<String,String> Parameters = StringMap()) throw (Exception);
99	schoenebeck	880	DeviceCreationParameter* Create(String ParameterName, String val) throw (Exception);
100	senkov	174
101	persson	1889	~DeviceParameterFactory();
102
103	senkov	174	protected:
104			std::map<String, InnerFactory*> InnerFactories;
105			};
106
107			} // namespace LinuxSampler
108
109			#endif // __LS_DEVICE_PARAMETER_FACTORY_H__