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 ~DeviceRuntimeParameterString(){}
            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 ~DeviceRuntimeParameterStrings(){}
            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 ~DeviceCreationParameterString(){}
            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 ~DeviceCreationParameterStrings(){}
            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	/***************************************************************************
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	#include "Device.h"
33
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	virtual void SetValue(bool b) throw (LinuxSamplerException);
64
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	virtual void SetValue(int i) throw (LinuxSamplerException);
83
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	virtual void SetValue(float f) throw (LinuxSamplerException);
105
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 ~DeviceRuntimeParameterString(){}
118	virtual String Type();
119	virtual bool Multiplicity();
120	virtual optional<String> RangeMin();
121	virtual optional<String> RangeMax();
122	virtual optional<String> Possibilities();
123	virtual String Value();
124	virtual void SetValue(String val) throw (LinuxSamplerException);
125
126	virtual String ValueAsString();
127	virtual void SetValueAsString(String s) throw (LinuxSamplerException);
128
129	virtual std::vector<String> PossibilitiesAsString() = 0;
130	virtual void OnSetValue(String s) = 0;
131	protected:
132	String sVal;
133	};
134
135	class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
136	public:
137	DeviceRuntimeParameterStrings(std::vector<String> vS);
138	virtual ~DeviceRuntimeParameterStrings(){}
139	virtual String Type();
140	virtual bool Multiplicity();
141	virtual optional<String> RangeMin();
142	virtual optional<String> RangeMax();
143	virtual optional<String> Possibilities();
144	virtual String Value();
145	virtual void SetValue(String val) throw (LinuxSamplerException);
146
147	virtual std::vector<String> ValueAsStrings();
148	virtual void SetValue(std::vector<String> vS) throw (LinuxSamplerException);
149
150	virtual std::vector<String> PossibilitiesAsString() = 0;
151	virtual void OnSetValue(std::vector<String> vS) = 0;
152	protected:
153	std::vector<String> sVals;
154	};
155
156
157
158	class DeviceCreationParameter : public DeviceRuntimeParameter {
159	public:
160	DeviceCreationParameter ( void ) { pDevice = NULL; }
161	virtual bool Mandatory() = 0;
162	virtual optional<String> Depends();
163	virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
164	virtual optional<String> Default();
165	virtual optional<String> Default(std::map<String,String> Parameters) = 0;
166	virtual optional<String> RangeMin();
167	virtual optional<String> RangeMin(std::map<String,String> Parameters) = 0;
168	virtual optional<String> RangeMax();
169	virtual optional<String> RangeMax(std::map<String,String> Parameters) = 0;
170	virtual optional<String> Possibilities();
171	virtual optional<String> Possibilities(std::map<String,String> Parameters) = 0;
172	void Attach(Device* pDevice) { this->pDevice = pDevice; }
173	protected:
174	Device* pDevice;
175	};
176
177	class DeviceCreationParameterBool : public DeviceCreationParameter {
178	public:
179	DeviceCreationParameterBool(bool bVal = false);
180	DeviceCreationParameterBool(String val) throw (LinuxSamplerException);
181	virtual String Type();
182	virtual bool Multiplicity();
183	virtual optional<String> Default(std::map<String,String> Parameters);
184	virtual optional<String> RangeMin(std::map<String,String> Parameters);
185	virtual optional<String> RangeMax(std::map<String,String> Parameters);
186	virtual optional<String> Possibilities(std::map<String,String> Parameters);
187	virtual String Value();
188	virtual void SetValue(String val) throw (LinuxSamplerException);
189
190	virtual bool ValueAsBool();
191	virtual void SetValue(bool b) throw (LinuxSamplerException);
192
193	virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
194	virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
195	protected:
196	bool bVal;
197	void InitWithDefault();
198	private:
199	};
200
201	class DeviceCreationParameterInt : public DeviceCreationParameter {
202	public:
203	DeviceCreationParameterInt(int iVal = 0);
204	DeviceCreationParameterInt(String val) throw (LinuxSamplerException);
205	virtual String Type();
206	virtual bool Multiplicity();
207	virtual optional<String> Default(std::map<String,String> Parameters);
208	virtual optional<String> RangeMin(std::map<String,String> Parameters);
209	virtual optional<String> RangeMax(std::map<String,String> Parameters);
210	virtual optional<String> Possibilities(std::map<String,String> Parameters);
211	virtual String Value();
212	virtual void SetValue(String val) throw (LinuxSamplerException);
213
214	virtual int ValueAsInt();
215	virtual void SetValue(int i) throw (LinuxSamplerException);
216
217	virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) = 0;
218	virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters) = 0;
219	virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters) = 0;
220	virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
221	virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
222	protected:
223	int iVal;
224	void InitWithDefault();
225	private:
226	};
227
228	class DeviceCreationParameterFloat : public DeviceCreationParameter {
229	public:
230	DeviceCreationParameterFloat(float fVal = 0.0);
231	DeviceCreationParameterFloat(String val) throw (LinuxSamplerException);
232	virtual String Type();
233	virtual bool Multiplicity();
234	virtual optional<String> Default(std::map<String,String> Parameters);
235	virtual optional<String> RangeMin(std::map<String,String> Parameters);
236	virtual optional<String> RangeMax(std::map<String,String> Parameters);
237	virtual optional<String> Possibilities(std::map<String,String> Parameters);
238	virtual String Value();
239	virtual void SetValue(String val) throw (LinuxSamplerException);
240
241	virtual float ValueAsFloat();
242	virtual void SetValue(float f) throw (LinuxSamplerException);
243
244	virtual optional<float> DefaultAsFloat(std::map<String,String> Parameters) = 0;
245	virtual optional<float> RangeMinAsFloat(std::map<String,String> Parameters) = 0;
246	virtual optional<float> RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
247	virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
248	virtual void OnSetValue(float f) throw (LinuxSamplerException) = 0;
249	protected:
250	float fVal;
251	void InitWithDefault();
252	private:
253	};
254
255	class DeviceCreationParameterString : public DeviceCreationParameter {
256	public:
257	DeviceCreationParameterString(String sVal = String());
258	virtual ~DeviceCreationParameterString(){}
259	virtual String Type();
260	virtual bool Multiplicity();
261	virtual optional<String> Default(std::map<String,String> Parameters);
262	virtual optional<String> RangeMin(std::map<String,String> Parameters);
263	virtual optional<String> RangeMax(std::map<String,String> Parameters);
264	virtual optional<String> Possibilities(std::map<String,String> Parameters);
265	virtual String Value();
266	virtual void SetValue(String val) throw (LinuxSamplerException);
267
268	virtual String ValueAsString();
269	virtual void SetValueAsString(String s) throw (LinuxSamplerException);
270
271	virtual optional<String> DefaultAsString(std::map<String,String> Parameters) = 0;
272	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
273	virtual void OnSetValue(String s) throw (LinuxSamplerException) = 0;
274	protected:
275	String sVal;
276	void InitWithDefault();
277	private:
278	};
279
280	class DeviceCreationParameterStrings : public DeviceCreationParameter {
281	public:
282	DeviceCreationParameterStrings();
283	DeviceCreationParameterStrings(std::vector<String> sVals);
284	DeviceCreationParameterStrings(String val) throw (LinuxSamplerException);
285	virtual ~DeviceCreationParameterStrings(){}
286	virtual String Type();
287	virtual bool Multiplicity();
288	virtual optional<String> Default(std::map<String,String> Parameters);
289	virtual optional<String> RangeMin(std::map<String,String> Parameters);
290	virtual optional<String> RangeMax(std::map<String,String> Parameters);
291	virtual optional<String> Possibilities(std::map<String,String> Parameters);
292	virtual String Value();
293	virtual void SetValue(String val) throw (LinuxSamplerException);
294
295	virtual std::vector<String> ValueAsStrings();
296	virtual void SetValue(std::vector<String> vS) throw (LinuxSamplerException);
297
298	virtual std::vector<String> DefaultAsStrings(std::map<String,String> Parameters) = 0;
299	virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
300	virtual void OnSetValue(std::vector<String> vS) throw (LinuxSamplerException) = 0;
301	protected:
302	std::vector<String> sVals;
303	void InitWithDefault();
304	private:
305	};
306
307	} // namespace LinuxSampler
308
309	#endif // __LS_DEVICE_PARAMETER_H__