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"
#include "Device.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) throw (LinuxSamplerException);

            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) throw (LinuxSamplerException);

            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) throw (LinuxSamplerException);

            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 String ValueAsString();
            virtual void   SetValueAsString(String s) 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) throw (LinuxSamplerException);

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


    class DeviceCreationParameter : public DeviceRuntimeParameter {
        public:
            DeviceCreationParameter ( void )                  { pDevice = NULL; }
            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;
            void                                              Attach(Device* pDevice) { this->pDevice = pDevice; }
        protected:
            Device* pDevice;
    };

    class DeviceCreationParameterBool : public DeviceCreationParameter {
        public:
            DeviceCreationParameterBool(bool bVal = false);
            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) throw (LinuxSamplerException);

            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(int iVal = 0);
            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) throw (LinuxSamplerException);

            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(float fVal = 0.0);
            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) throw (LinuxSamplerException);

            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(String sVal = String());
            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 String ValueAsString();
            virtual void   SetValueAsString(String s) throw (LinuxSamplerException);

            virtual optional<String>    DefaultAsString(std::map<String,String> Parameters) = 0;
            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> 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 std::vector<String> ValueAsStrings();
            virtual void                SetValue(std::vector<String> vS) throw (LinuxSamplerException);

            virtual 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	schoenebeck	123	/***************************************************************************
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	schoenebeck	207	#include "Device.h"
33	schoenebeck	123
34			namespace LinuxSampler {
35
36			// 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.
37
38			class DeviceRuntimeParameter {
39			public:
40			virtual String Type() = 0;
41			virtual String Description() = 0;
42			virtual bool Fix() = 0;
43			virtual bool Multiplicity() = 0;
44			virtual optional<String> RangeMin() = 0;
45			virtual optional<String> RangeMax() = 0;
46			virtual optional<String> Possibilities() = 0;
47			virtual String Value() = 0;
48			virtual void SetValue(String val) throw (LinuxSamplerException) = 0;
49			};
50
51			class DeviceRuntimeParameterBool : public DeviceRuntimeParameter {
52			public:
53			DeviceRuntimeParameterBool(bool bVal);
54			virtual String Type();
55			virtual bool Multiplicity();
56			virtual optional<String> RangeMin();
57			virtual optional<String> RangeMax();
58			virtual optional<String> Possibilities();
59			virtual String Value();
60			virtual void SetValue(String val) throw (LinuxSamplerException);
61
62			virtual bool ValueAsBool();
63	schoenebeck	214	virtual void SetValue(bool b) throw (LinuxSamplerException);
64	schoenebeck	123
65			virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
66			protected:
67			bool bVal;
68			};
69
70			class DeviceRuntimeParameterInt : public DeviceRuntimeParameter {
71			public:
72			DeviceRuntimeParameterInt(int iVal);
73			virtual String Type();
74			virtual bool Multiplicity();
75			virtual optional<String> RangeMin();
76			virtual optional<String> RangeMax();
77			virtual optional<String> Possibilities();
78			virtual String Value();
79			virtual void SetValue(String val) throw (LinuxSamplerException);
80
81			virtual int ValueAsInt();
82	schoenebeck	214	virtual void SetValue(int i) throw (LinuxSamplerException);
83	schoenebeck	123
84			virtual optional<int> RangeMinAsInt() = 0;
85			virtual optional<int> RangeMaxAsInt() = 0;
86			virtual std::vector<int> PossibilitiesAsInt() = 0;
87			virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
88			protected:
89			int iVal;
90			};
91
92			class DeviceRuntimeParameterFloat : public DeviceRuntimeParameter {
93			public:
94			DeviceRuntimeParameterFloat(float fVal);
95			virtual String Type();
96			virtual bool Multiplicity();
97			virtual optional<String> RangeMin();
98			virtual optional<String> RangeMax();
99			virtual optional<String> Possibilities();
100			virtual String Value();
101			virtual void SetValue(String val) throw (LinuxSamplerException);
102
103			virtual float ValueAsFloat();
104	schoenebeck	214	virtual void SetValue(float f) throw (LinuxSamplerException);
105	schoenebeck	123
106			virtual optional<float> RangeMinAsFloat() = 0;
107			virtual optional<float> RangeMaxAsFloat() = 0;
108			virtual std::vector<float> PossibilitiesAsFloat() = 0;
109			virtual void OnSetValue(float f) = 0;
110			protected:
111			float fVal;
112			};
113
114			class DeviceRuntimeParameterString : public DeviceRuntimeParameter {
115			public:
116			DeviceRuntimeParameterString(String sVal);
117			virtual String Type();
118			virtual bool Multiplicity();
119			virtual optional<String> RangeMin();
120			virtual optional<String> RangeMax();
121			virtual optional<String> Possibilities();
122			virtual String Value();
123			virtual void SetValue(String val) throw (LinuxSamplerException);
124
125	schoenebeck	214	virtual String ValueAsString();
126			virtual void SetValueAsString(String s) throw (LinuxSamplerException);
127
128	schoenebeck	123	virtual std::vector<String> PossibilitiesAsString() = 0;
129			virtual void OnSetValue(String s) = 0;
130			protected:
131			String sVal;
132			};
133
134			class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
135			public:
136			DeviceRuntimeParameterStrings(std::vector<String> vS);
137			virtual String Type();
138			virtual bool Multiplicity();
139			virtual optional<String> RangeMin();
140			virtual optional<String> RangeMax();
141			virtual optional<String> Possibilities();
142			virtual String Value();
143			virtual void SetValue(String val) throw (LinuxSamplerException);
144
145			virtual std::vector<String> ValueAsStrings();
146	schoenebeck	214	virtual void SetValue(std::vector<String> vS) throw (LinuxSamplerException);
147	schoenebeck	123
148			virtual std::vector<String> PossibilitiesAsString() = 0;
149			virtual void OnSetValue(std::vector<String> vS) = 0;
150			protected:
151			std::vector<String> sVals;
152			};
153
154
155
156			class DeviceCreationParameter : public DeviceRuntimeParameter {
157			public:
158	senkov	174	DeviceCreationParameter ( void ) { pDevice = NULL; }
159	schoenebeck	123	virtual bool Mandatory() = 0;
160			virtual optional<String> Depends();
161			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
162			virtual optional<String> Default();
163			virtual optional<String> Default(std::map<String,String> Parameters) = 0;
164			virtual optional<String> RangeMin();
165			virtual optional<String> RangeMin(std::map<String,String> Parameters) = 0;
166			virtual optional<String> RangeMax();
167			virtual optional<String> RangeMax(std::map<String,String> Parameters) = 0;
168			virtual optional<String> Possibilities();
169			virtual optional<String> Possibilities(std::map<String,String> Parameters) = 0;
170	schoenebeck	207	void Attach(Device* pDevice) { this->pDevice = pDevice; }
171	senkov	174	protected:
172	schoenebeck	207	Device* pDevice;
173	schoenebeck	123	};
174
175			class DeviceCreationParameterBool : public DeviceCreationParameter {
176			public:
177	senkov	174	DeviceCreationParameterBool(bool bVal = false);
178	schoenebeck	123	DeviceCreationParameterBool(String val) throw (LinuxSamplerException);
179			virtual String Type();
180			virtual bool Multiplicity();
181			virtual optional<String> Default(std::map<String,String> Parameters);
182			virtual optional<String> RangeMin(std::map<String,String> Parameters);
183			virtual optional<String> RangeMax(std::map<String,String> Parameters);
184			virtual optional<String> Possibilities(std::map<String,String> Parameters);
185			virtual String Value();
186			virtual void SetValue(String val) throw (LinuxSamplerException);
187
188			virtual bool ValueAsBool();
189	schoenebeck	214	virtual void SetValue(bool b) throw (LinuxSamplerException);
190	schoenebeck	123
191			virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
192			virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
193			protected:
194			bool bVal;
195	senkov	128	void InitWithDefault();
196	schoenebeck	123	private:
197			};
198
199			class DeviceCreationParameterInt : public DeviceCreationParameter {
200			public:
201	senkov	174	DeviceCreationParameterInt(int iVal = 0);
202	schoenebeck	123	DeviceCreationParameterInt(String val) throw (LinuxSamplerException);
203			virtual String Type();
204			virtual bool Multiplicity();
205			virtual optional<String> Default(std::map<String,String> Parameters);
206			virtual optional<String> RangeMin(std::map<String,String> Parameters);
207			virtual optional<String> RangeMax(std::map<String,String> Parameters);
208			virtual optional<String> Possibilities(std::map<String,String> Parameters);
209			virtual String Value();
210			virtual void SetValue(String val) throw (LinuxSamplerException);
211
212			virtual int ValueAsInt();
213	schoenebeck	214	virtual void SetValue(int i) throw (LinuxSamplerException);
214	schoenebeck	123
215			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) = 0;
216			virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters) = 0;
217			virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters) = 0;
218			virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
219			virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
220			protected:
221			int iVal;
222	senkov	128	void InitWithDefault();
223	schoenebeck	123	private:
224			};
225
226			class DeviceCreationParameterFloat : public DeviceCreationParameter {
227			public:
228	senkov	174	DeviceCreationParameterFloat(float fVal = 0.0);
229	schoenebeck	123	DeviceCreationParameterFloat(String val) throw (LinuxSamplerException);
230			virtual String Type();
231			virtual bool Multiplicity();
232			virtual optional<String> Default(std::map<String,String> Parameters);
233			virtual optional<String> RangeMin(std::map<String,String> Parameters);
234			virtual optional<String> RangeMax(std::map<String,String> Parameters);
235			virtual optional<String> Possibilities(std::map<String,String> Parameters);
236			virtual String Value();
237			virtual void SetValue(String val) throw (LinuxSamplerException);
238
239			virtual float ValueAsFloat();
240	schoenebeck	214	virtual void SetValue(float f) throw (LinuxSamplerException);
241	schoenebeck	123
242			virtual optional<float> DefaultAsFloat(std::map<String,String> Parameters) = 0;
243			virtual optional<float> RangeMinAsFloat(std::map<String,String> Parameters) = 0;
244			virtual optional<float> RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
245			virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
246			virtual void OnSetValue(float f) throw (LinuxSamplerException) = 0;
247			protected:
248			float fVal;
249	senkov	128	void InitWithDefault();
250	schoenebeck	123	private:
251			};
252
253			class DeviceCreationParameterString : public DeviceCreationParameter {
254			public:
255	senkov	174	DeviceCreationParameterString(String sVal = String());
256	schoenebeck	123	virtual String Type();
257			virtual bool Multiplicity();
258	schoenebeck	212	virtual optional<String> Default(std::map<String,String> Parameters);
259	schoenebeck	123	virtual optional<String> RangeMin(std::map<String,String> Parameters);
260			virtual optional<String> RangeMax(std::map<String,String> Parameters);
261			virtual optional<String> Possibilities(std::map<String,String> Parameters);
262			virtual String Value();
263			virtual void SetValue(String val) throw (LinuxSamplerException);
264
265	schoenebeck	214	virtual String ValueAsString();
266			virtual void SetValueAsString(String s) throw (LinuxSamplerException);
267
268	schoenebeck	212	virtual optional<String> DefaultAsString(std::map<String,String> Parameters) = 0;
269	schoenebeck	123	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
270			virtual void OnSetValue(String s) throw (LinuxSamplerException) = 0;
271			protected:
272			String sVal;
273	senkov	128	void InitWithDefault();
274	schoenebeck	123	private:
275			};
276
277			class DeviceCreationParameterStrings : public DeviceCreationParameter {
278			public:
279			DeviceCreationParameterStrings();
280			DeviceCreationParameterStrings(std::vector<String> sVals);
281			DeviceCreationParameterStrings(String val) throw (LinuxSamplerException);
282			virtual String Type();
283			virtual bool Multiplicity();
284	schoenebeck	212	virtual optional<String> Default(std::map<String,String> Parameters);
285	schoenebeck	123	virtual optional<String> RangeMin(std::map<String,String> Parameters);
286			virtual optional<String> RangeMax(std::map<String,String> Parameters);
287			virtual optional<String> Possibilities(std::map<String,String> Parameters);
288			virtual String Value();
289			virtual void SetValue(String val) throw (LinuxSamplerException);
290
291			virtual std::vector<String> ValueAsStrings();
292	schoenebeck	214	virtual void SetValue(std::vector<String> vS) throw (LinuxSamplerException);
293	schoenebeck	123
294	schoenebeck	212	virtual std::vector<String> DefaultAsStrings(std::map<String,String> Parameters) = 0;
295	schoenebeck	123	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
296			virtual void OnSetValue(std::vector<String> vS) throw (LinuxSamplerException) = 0;
297			protected:
298			std::vector<String> sVals;
299	senkov	128	void InitWithDefault();
300	schoenebeck	123	private:
301			};
302
303			} // namespace LinuxSampler
304
305			#endif // __LS_DEVICE_PARAMETER_H__