src/drivers/DeviceParameter.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and 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_H__
#define __LS_DEVICE_PARAMETER_H__

#include <map>
#include <vector>

#include "../common/global.h"
#include "../common/optional.h"
#include "../common/LinuxSamplerException.h"

namespace LinuxSampler {

    // TODO: All plurar parameter classes (except for String) have to be added (namely DeviceRuntimeParameterBools, DeviceRuntimeParameterInts, DeviceRuntimeParameterFloats, DeviceCreationParameterBools, DeviceCreationParameterInts, DeviceCreationParameterFloats), I ignored them for the moment, because they were not that necessary.

    class DeviceRuntimeParameter {
        public:
            virtual String           Type()          = 0;
            virtual String           Description()   = 0;
            virtual bool             Fix()           = 0;
            virtual bool             Multiplicity()  = 0;
            virtual optional<String> RangeMin()      = 0;
            virtual optional<String> RangeMax()      = 0;
            virtual optional<String> Possibilities() = 0;
            virtual String           Value()         = 0;
            virtual void             SetValue(String val) throw (LinuxSamplerException) = 0;
    };

    class DeviceRuntimeParameterBool : public DeviceRuntimeParameter {
        public:
            DeviceRuntimeParameterBool(bool bVal);
            virtual String           Type();
            virtual bool             Multiplicity();
            virtual optional<String> RangeMin();
            virtual optional<String> RangeMax();
            virtual optional<String> Possibilities();
            virtual String           Value();
            virtual void             SetValue(String val) throw (LinuxSamplerException);

            virtual bool ValueAsBool();
            virtual void SetValue(bool b);

            virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
        protected:
            bool bVal;
    };

    class DeviceRuntimeParameterInt : public DeviceRuntimeParameter {
        public:
            DeviceRuntimeParameterInt(int iVal);
            virtual String           Type();
            virtual bool             Multiplicity();
            virtual optional<String> RangeMin();
            virtual optional<String> RangeMax();
            virtual optional<String> Possibilities();
            virtual String           Value();
            virtual void             SetValue(String val) throw (LinuxSamplerException);

            virtual int  ValueAsInt();
            virtual void SetValue(int i);

            virtual optional<int>    RangeMinAsInt()      = 0;
            virtual optional<int>    RangeMaxAsInt()      = 0;
            virtual std::vector<int> PossibilitiesAsInt() = 0;
            virtual void             OnSetValue(int i) throw (LinuxSamplerException) = 0;
        protected:
            int iVal;
    };

    class DeviceRuntimeParameterFloat : public DeviceRuntimeParameter {
        public:
            DeviceRuntimeParameterFloat(float fVal);
            virtual String           Type();
            virtual bool             Multiplicity();
            virtual optional<String> RangeMin();
            virtual optional<String> RangeMax();
            virtual optional<String> Possibilities();
            virtual String           Value();
            virtual void             SetValue(String val) throw (LinuxSamplerException);

            virtual float ValueAsFloat();
            virtual void  SetValue(float f);

            virtual optional<float>     RangeMinAsFloat()      = 0;
            virtual optional<float>     RangeMaxAsFloat()      = 0;
            virtual std::vector<float>  PossibilitiesAsFloat() = 0;
            virtual void                OnSetValue(float f) = 0;
        protected:
            float fVal;
    };

    class DeviceRuntimeParameterString : public DeviceRuntimeParameter {
        public:
            DeviceRuntimeParameterString(String sVal);
            virtual String           Type();
            virtual bool             Multiplicity();
            virtual optional<String> RangeMin();
            virtual optional<String> RangeMax();
            virtual optional<String> Possibilities();
            virtual String           Value();
            virtual void             SetValue(String val) throw (LinuxSamplerException);

            virtual std::vector<String> PossibilitiesAsString() = 0;
            virtual void                OnSetValue(String s)    = 0;
        protected:
            String sVal;
    };

    class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
        public:
            DeviceRuntimeParameterStrings(std::vector<String> vS);
            virtual String           Type();
            virtual bool             Multiplicity();
            virtual optional<String> RangeMin();
            virtual optional<String> RangeMax();
            virtual optional<String> Possibilities();
            virtual String           Value();
            virtual void             SetValue(String val) throw (LinuxSamplerException);

            virtual std::vector<String> ValueAsStrings();
            virtual void                SetValue(std::vector<String> vS);

            virtual std::vector<String> PossibilitiesAsString()            = 0;
            virtual void                OnSetValue(std::vector<String> vS) = 0;
        protected:
            std::vector<String> sVals;
    };


    class DeviceCreationParameter : public DeviceRuntimeParameter {
        public:
            virtual bool                                      Mandatory() = 0;
            virtual optional<String>                          Depends();
            virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
            virtual optional<String>                          Default();
            virtual optional<String>                          Default(std::map<String,String> Parameters) = 0;
            virtual optional<String>                          RangeMin();
            virtual optional<String>                          RangeMin(std::map<String,String> Parameters) = 0;
            virtual optional<String>                          RangeMax();
            virtual optional<String>                          RangeMax(std::map<String,String> Parameters) = 0;
            virtual optional<String>                          Possibilities();
            virtual optional<String>                          Possibilities(std::map<String,String> Parameters) = 0;
    };

    class DeviceCreationParameterBool : public DeviceCreationParameter {
        public:
            DeviceCreationParameterBool();
            DeviceCreationParameterBool(bool bVal);
            DeviceCreationParameterBool(String val) throw (LinuxSamplerException);
            virtual String Type();
            virtual bool   Multiplicity();
            virtual optional<String> Default(std::map<String,String> Parameters);
            virtual optional<String> RangeMin(std::map<String,String> Parameters);
            virtual optional<String> RangeMax(std::map<String,String> Parameters);
            virtual optional<String> Possibilities(std::map<String,String> Parameters);
            virtual String Value();
            virtual void   SetValue(String val) throw (LinuxSamplerException);

            virtual bool ValueAsBool();
            virtual void SetValue(bool b);

            virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
            virtual void OnSetValue(bool b) throw (LinuxSamplerException)  = 0;
        protected:
            bool bVal;
            void InitWithDefault();
        private:
    };

    class DeviceCreationParameterInt : public DeviceCreationParameter {
        public:
            DeviceCreationParameterInt();
            DeviceCreationParameterInt(int iVal);
            DeviceCreationParameterInt(String val) throw (LinuxSamplerException);
            virtual String Type();
            virtual bool   Multiplicity();
            virtual optional<String> Default(std::map<String,String> Parameters);
            virtual optional<String> RangeMin(std::map<String,String> Parameters);
            virtual optional<String> RangeMax(std::map<String,String> Parameters);
            virtual optional<String> Possibilities(std::map<String,String> Parameters);
            virtual String Value();
            virtual void   SetValue(String val) throw (LinuxSamplerException);

            virtual int  ValueAsInt();
            virtual void SetValue(int i);

            virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters)  = 0;
            virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters) = 0;
            virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters) = 0;
            virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
            virtual void             OnSetValue(int i) throw (LinuxSamplerException)  = 0;
        protected:
            int iVal;
            void InitWithDefault();
        private:
    };

    class DeviceCreationParameterFloat : public DeviceCreationParameter {
        public:
            DeviceCreationParameterFloat();
            DeviceCreationParameterFloat(float fVal);
            DeviceCreationParameterFloat(String val) throw (LinuxSamplerException);
            virtual String Type();
            virtual bool   Multiplicity();
            virtual optional<String> Default(std::map<String,String> Parameters);
            virtual optional<String> RangeMin(std::map<String,String> Parameters);
            virtual optional<String> RangeMax(std::map<String,String> Parameters);
            virtual optional<String> Possibilities(std::map<String,String> Parameters);
            virtual String Value();
            virtual void   SetValue(String val) throw (LinuxSamplerException);

            virtual float ValueAsFloat();
            virtual void  SetValue(float f);

            virtual optional<float>    DefaultAsFloat(std::map<String,String> Parameters)  = 0;
            virtual optional<float>    RangeMinAsFloat(std::map<String,String> Parameters) = 0;
            virtual optional<float>    RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
            virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
            virtual void OnSetValue(float f) throw (LinuxSamplerException)  = 0;
        protected:
            float fVal;
            void InitWithDefault();
        private:
    };

    class DeviceCreationParameterString : public DeviceCreationParameter {
        public:
            DeviceCreationParameterString();
            DeviceCreationParameterString(String sVal);
            virtual String Type();
            virtual bool   Multiplicity();
            virtual optional<String> RangeMin(std::map<String,String> Parameters);
            virtual optional<String> RangeMax(std::map<String,String> Parameters);
            virtual optional<String> Possibilities(std::map<String,String> Parameters);
            virtual String Value();
            virtual void   SetValue(String val) throw (LinuxSamplerException);

            virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
            virtual void OnSetValue(String s) throw (LinuxSamplerException) = 0;
        protected:
            String sVal;
            void InitWithDefault();
        private:
    };

    class DeviceCreationParameterStrings : public DeviceCreationParameter {
        public:
            DeviceCreationParameterStrings();
            DeviceCreationParameterStrings(std::vector<String> sVals);
            DeviceCreationParameterStrings(String val) throw (LinuxSamplerException);
            virtual String Type();
            virtual bool   Multiplicity();
            virtual optional<String> RangeMin(std::map<String,String> Parameters);
            virtual optional<String> RangeMax(std::map<String,String> Parameters);
            virtual optional<String> Possibilities(std::map<String,String> Parameters);
            virtual String Value();
            virtual void   SetValue(String val) throw (LinuxSamplerException);

            virtual std::vector<String> ValueAsStrings();
            virtual void                SetValue(std::vector<String> vS);

            virtual optional<std::vector<String> > DefaultAsStrings(std::map<String,String> Parameters) = 0;
            virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
            virtual void OnSetValue(std::vector<String> vS) throw (LinuxSamplerException) = 0;
        protected:
            std::vector<String> sVals;
            void InitWithDefault();
        private:
    };

} // namespace LinuxSampler

#endif // __LS_DEVICE_PARAMETER_H__
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* *
7	* This program is free software; you can redistribute it and/or modify *
8	* it under the terms of the GNU General Public License as published by *
9	* the Free Software Foundation; either version 2 of the License, or *
10	* (at your option) any later version. *
11	* *
12	* This program is distributed in the hope that it will be useful, *
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15	* GNU General Public License for more details. *
16	* *
17	* You should have received a copy of the GNU General Public License *
18	* along with this program; if not, write to the Free Software *
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20	* MA 02111-1307 USA *
21	***************************************************************************/
22
23	#ifndef __LS_DEVICE_PARAMETER_H__
24	#define __LS_DEVICE_PARAMETER_H__
25
26	#include <map>
27	#include <vector>
28
29	#include "../common/global.h"
30	#include "../common/optional.h"
31	#include "../common/LinuxSamplerException.h"
32
33	namespace LinuxSampler {
34
35	// TODO: All plurar parameter classes (except for String) have to be added (namely DeviceRuntimeParameterBools, DeviceRuntimeParameterInts, DeviceRuntimeParameterFloats, DeviceCreationParameterBools, DeviceCreationParameterInts, DeviceCreationParameterFloats), I ignored them for the moment, because they were not that necessary.
36
37	class DeviceRuntimeParameter {
38	public:
39	virtual String Type() = 0;
40	virtual String Description() = 0;
41	virtual bool Fix() = 0;
42	virtual bool Multiplicity() = 0;
43	virtual optional<String> RangeMin() = 0;
44	virtual optional<String> RangeMax() = 0;
45	virtual optional<String> Possibilities() = 0;
46	virtual String Value() = 0;
47	virtual void SetValue(String val) throw (LinuxSamplerException) = 0;
48	};
49
50	class DeviceRuntimeParameterBool : public DeviceRuntimeParameter {
51	public:
52	DeviceRuntimeParameterBool(bool bVal);
53	virtual String Type();
54	virtual bool Multiplicity();
55	virtual optional<String> RangeMin();
56	virtual optional<String> RangeMax();
57	virtual optional<String> Possibilities();
58	virtual String Value();
59	virtual void SetValue(String val) throw (LinuxSamplerException);
60
61	virtual bool ValueAsBool();
62	virtual void SetValue(bool b);
63
64	virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
65	protected:
66	bool bVal;
67	};
68
69	class DeviceRuntimeParameterInt : public DeviceRuntimeParameter {
70	public:
71	DeviceRuntimeParameterInt(int iVal);
72	virtual String Type();
73	virtual bool Multiplicity();
74	virtual optional<String> RangeMin();
75	virtual optional<String> RangeMax();
76	virtual optional<String> Possibilities();
77	virtual String Value();
78	virtual void SetValue(String val) throw (LinuxSamplerException);
79
80	virtual int ValueAsInt();
81	virtual void SetValue(int i);
82
83	virtual optional<int> RangeMinAsInt() = 0;
84	virtual optional<int> RangeMaxAsInt() = 0;
85	virtual std::vector<int> PossibilitiesAsInt() = 0;
86	virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
87	protected:
88	int iVal;
89	};
90
91	class DeviceRuntimeParameterFloat : public DeviceRuntimeParameter {
92	public:
93	DeviceRuntimeParameterFloat(float fVal);
94	virtual String Type();
95	virtual bool Multiplicity();
96	virtual optional<String> RangeMin();
97	virtual optional<String> RangeMax();
98	virtual optional<String> Possibilities();
99	virtual String Value();
100	virtual void SetValue(String val) throw (LinuxSamplerException);
101
102	virtual float ValueAsFloat();
103	virtual void SetValue(float f);
104
105	virtual optional<float> RangeMinAsFloat() = 0;
106	virtual optional<float> RangeMaxAsFloat() = 0;
107	virtual std::vector<float> PossibilitiesAsFloat() = 0;
108	virtual void OnSetValue(float f) = 0;
109	protected:
110	float fVal;
111	};
112
113	class DeviceRuntimeParameterString : public DeviceRuntimeParameter {
114	public:
115	DeviceRuntimeParameterString(String sVal);
116	virtual String Type();
117	virtual bool Multiplicity();
118	virtual optional<String> RangeMin();
119	virtual optional<String> RangeMax();
120	virtual optional<String> Possibilities();
121	virtual String Value();
122	virtual void SetValue(String val) throw (LinuxSamplerException);
123
124	virtual std::vector<String> PossibilitiesAsString() = 0;
125	virtual void OnSetValue(String s) = 0;
126	protected:
127	String sVal;
128	};
129
130	class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
131	public:
132	DeviceRuntimeParameterStrings(std::vector<String> vS);
133	virtual String Type();
134	virtual bool Multiplicity();
135	virtual optional<String> RangeMin();
136	virtual optional<String> RangeMax();
137	virtual optional<String> Possibilities();
138	virtual String Value();
139	virtual void SetValue(String val) throw (LinuxSamplerException);
140
141	virtual std::vector<String> ValueAsStrings();
142	virtual void SetValue(std::vector<String> vS);
143
144	virtual std::vector<String> PossibilitiesAsString() = 0;
145	virtual void OnSetValue(std::vector<String> vS) = 0;
146	protected:
147	std::vector<String> sVals;
148	};
149
150
151
152	class DeviceCreationParameter : public DeviceRuntimeParameter {
153	public:
154	virtual bool Mandatory() = 0;
155	virtual optional<String> Depends();
156	virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
157	virtual optional<String> Default();
158	virtual optional<String> Default(std::map<String,String> Parameters) = 0;
159	virtual optional<String> RangeMin();
160	virtual optional<String> RangeMin(std::map<String,String> Parameters) = 0;
161	virtual optional<String> RangeMax();
162	virtual optional<String> RangeMax(std::map<String,String> Parameters) = 0;
163	virtual optional<String> Possibilities();
164	virtual optional<String> Possibilities(std::map<String,String> Parameters) = 0;
165	};
166
167	class DeviceCreationParameterBool : public DeviceCreationParameter {
168	public:
169	DeviceCreationParameterBool();
170	DeviceCreationParameterBool(bool bVal);
171	DeviceCreationParameterBool(String val) throw (LinuxSamplerException);
172	virtual String Type();
173	virtual bool Multiplicity();
174	virtual optional<String> Default(std::map<String,String> Parameters);
175	virtual optional<String> RangeMin(std::map<String,String> Parameters);
176	virtual optional<String> RangeMax(std::map<String,String> Parameters);
177	virtual optional<String> Possibilities(std::map<String,String> Parameters);
178	virtual String Value();
179	virtual void SetValue(String val) throw (LinuxSamplerException);
180
181	virtual bool ValueAsBool();
182	virtual void SetValue(bool b);
183
184	virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
185	virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
186	protected:
187	bool bVal;
188	void InitWithDefault();
189	private:
190	};
191
192	class DeviceCreationParameterInt : public DeviceCreationParameter {
193	public:
194	DeviceCreationParameterInt();
195	DeviceCreationParameterInt(int iVal);
196	DeviceCreationParameterInt(String val) throw (LinuxSamplerException);
197	virtual String Type();
198	virtual bool Multiplicity();
199	virtual optional<String> Default(std::map<String,String> Parameters);
200	virtual optional<String> RangeMin(std::map<String,String> Parameters);
201	virtual optional<String> RangeMax(std::map<String,String> Parameters);
202	virtual optional<String> Possibilities(std::map<String,String> Parameters);
203	virtual String Value();
204	virtual void SetValue(String val) throw (LinuxSamplerException);
205
206	virtual int ValueAsInt();
207	virtual void SetValue(int i);
208
209	virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) = 0;
210	virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters) = 0;
211	virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters) = 0;
212	virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
213	virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
214	protected:
215	int iVal;
216	void InitWithDefault();
217	private:
218	};
219
220	class DeviceCreationParameterFloat : public DeviceCreationParameter {
221	public:
222	DeviceCreationParameterFloat();
223	DeviceCreationParameterFloat(float fVal);
224	DeviceCreationParameterFloat(String val) throw (LinuxSamplerException);
225	virtual String Type();
226	virtual bool Multiplicity();
227	virtual optional<String> Default(std::map<String,String> Parameters);
228	virtual optional<String> RangeMin(std::map<String,String> Parameters);
229	virtual optional<String> RangeMax(std::map<String,String> Parameters);
230	virtual optional<String> Possibilities(std::map<String,String> Parameters);
231	virtual String Value();
232	virtual void SetValue(String val) throw (LinuxSamplerException);
233
234	virtual float ValueAsFloat();
235	virtual void SetValue(float f);
236
237	virtual optional<float> DefaultAsFloat(std::map<String,String> Parameters) = 0;
238	virtual optional<float> RangeMinAsFloat(std::map<String,String> Parameters) = 0;
239	virtual optional<float> RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
240	virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
241	virtual void OnSetValue(float f) throw (LinuxSamplerException) = 0;
242	protected:
243	float fVal;
244	void InitWithDefault();
245	private:
246	};
247
248	class DeviceCreationParameterString : public DeviceCreationParameter {
249	public:
250	DeviceCreationParameterString();
251	DeviceCreationParameterString(String sVal);
252	virtual String Type();
253	virtual bool Multiplicity();
254	virtual optional<String> RangeMin(std::map<String,String> Parameters);
255	virtual optional<String> RangeMax(std::map<String,String> Parameters);
256	virtual optional<String> Possibilities(std::map<String,String> Parameters);
257	virtual String Value();
258	virtual void SetValue(String val) throw (LinuxSamplerException);
259
260	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
261	virtual void OnSetValue(String s) throw (LinuxSamplerException) = 0;
262	protected:
263	String sVal;
264	void InitWithDefault();
265	private:
266	};
267
268	class DeviceCreationParameterStrings : public DeviceCreationParameter {
269	public:
270	DeviceCreationParameterStrings();
271	DeviceCreationParameterStrings(std::vector<String> sVals);
272	DeviceCreationParameterStrings(String val) throw (LinuxSamplerException);
273	virtual String Type();
274	virtual bool Multiplicity();
275	virtual optional<String> RangeMin(std::map<String,String> Parameters);
276	virtual optional<String> RangeMax(std::map<String,String> Parameters);
277	virtual optional<String> Possibilities(std::map<String,String> Parameters);
278	virtual String Value();
279	virtual void SetValue(String val) throw (LinuxSamplerException);
280
281	virtual std::vector<String> ValueAsStrings();
282	virtual void SetValue(std::vector<String> vS);
283
284	virtual optional<std::vector<String> > DefaultAsStrings(std::map<String,String> Parameters) = 0;
285	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
286	virtual void OnSetValue(std::vector<String> vS) throw (LinuxSamplerException) = 0;
287	protected:
288	std::vector<String> sVals;
289	void InitWithDefault();
290	private:
291	};
292
293	} // namespace LinuxSampler
294
295	#endif // __LS_DEVICE_PARAMETER_H__