/[svn]/linuxsampler/trunk/src/drivers/DeviceParameter.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/DeviceParameter.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 123 - (show annotations) (download)
Mon Jun 14 19:33:16 2004 UTC (19 years, 9 months ago) by schoenebeck
File size: 28679 byte(s)
* src/common: added template class 'optional<>' which can be used e.g. as
  return type whenever a value might be returned, but don't has to; this
  template class pretty much acts like a pointer of the given type, but is
  much more safer than a simple pointer
* src/audiodriver: added static class AudioDeviceFactory to create audio
  devices at runtime by using a string and to obtain driver informations
  of drivers at runtime, driver classes should simply use the macro
  REGISTER_AUDIO_OUTPUT_DRIVER(DriverName,DriverClass) in their cpp file
  to register the driver to LinuxSampler (no changes needed anymore in the
  LS code to add a new audio output driver)
* src/drivers: added classes to dynamically manage driver parameters; there
  are two different kinds of parameters: parameters which are need to
  create a new device (DeviceCreationParameterX) used to e.g. create an
  audio output device or a MIDI input device and parameters which are only
  available at runtime, means when a device is already created
  (DeviceRuntimeParameterX) which will be e.g. used as audio channel
  parameters and MIDI port parameters
* src/linuxsampler.cpp: all registered audio output drivers will be shown
  on the console on startup
* src/network: implemented configuration of audio output devices via LSCP

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 #include <strings.h>
24 #include <stdlib.h>
25
26 #include "DeviceParameter.h"
27
28 namespace LinuxSampler {
29
30 static bool __parse_bool(String val) throw (LinuxSamplerException) {
31 int b;
32 if (val == "1" || !strcasecmp(val.c_str(),"true")) b = true;
33 else if (val == "0" || !strcasecmp(val.c_str(),"false")) b = false;
34 else throw LinuxSamplerException("Invalid value for boolean Device parameter");
35 return b;
36 }
37
38 static int __parse_int(String val) throw (LinuxSamplerException) {
39 return atoi(val.c_str()); // TODO: format check is missing
40 }
41
42 static float __parse_float(String val) throw (LinuxSamplerException) {
43 return atof(val.c_str()); // TODO: format check is missing
44 }
45
46 static std::vector<String> __parse_strings(String val) throw (LinuxSamplerException) {
47 std::vector<String> vS;
48
49 // if there's only a single value, then we also allow to give it without being encapsulted into apostrophes
50 if (val.find("\'") == String::npos && val.find("\"") == String::npos) {
51 vS.push_back(val);
52 }
53 else { // if multiple strings or a string encapsulated into apostrophes
54 char* pStart = (char*) val.c_str();
55 char* pC = pStart;
56 if (*pC != '\'' && *pC != '\"') throw LinuxSamplerException("Invalid form, all individual strings should be encapsulated into apostrophes, separated by commas");
57
58 while (true) {
59 // search for token end
60 char* pTokenStart = pC + 1;
61 do {
62 pC++;
63 if (*pC == '\0') throw LinuxSamplerException("Invalid form, all individual strings should be encapsulated into apostrophes, separated by commas");
64 }
65 while (*pC != '\'' && *pC != '\"');
66 vS.push_back(val.substr((int)(pTokenStart - pStart), (int)(pC - pTokenStart))); // we found the token's end
67
68 // now there should be either a comma or the end of the total string
69 if (*(++pC) == '\0') break;
70 if (*pC != ',') throw LinuxSamplerException("Invalid form, all individual strings should be encapsulated into apostrophes, separated by commas");
71 }
72 }
73
74 return vS;
75 }
76
77
78
79 // *************** DeviceRuntimeParameterBool ***************
80 // *
81
82 DeviceRuntimeParameterBool::DeviceRuntimeParameterBool(bool bVal) {
83 this->bVal = bVal;
84 }
85
86 String DeviceRuntimeParameterBool::Type() {
87 return "BOOL";
88 }
89
90 bool DeviceRuntimeParameterBool::Multiplicity() {
91 return false;
92 }
93
94 optional<String> DeviceRuntimeParameterBool::RangeMin() {
95 return optional<String>::nothing;
96 }
97
98 optional<String> DeviceRuntimeParameterBool::RangeMax() {
99 return optional<String>::nothing;
100 }
101
102 optional<String> DeviceRuntimeParameterBool::Possibilities() {
103 return optional<String>::nothing;
104 }
105
106 String DeviceRuntimeParameterBool::Value() {
107 return (ValueAsBool()) ? "TRUE" : "FALSE";
108 }
109
110 void DeviceRuntimeParameterBool::SetValue(String val) throw (LinuxSamplerException) {
111 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
112 int b = __parse_bool(val);
113 OnSetValue(b);
114 SetValue(b);
115 }
116
117 bool DeviceRuntimeParameterBool::ValueAsBool() {
118 return bVal;
119 }
120
121 void DeviceRuntimeParameterBool::SetValue(bool b) {
122 bVal = b;
123 }
124
125
126
127 // *************** DeviceRuntimeParameterInt ***************
128 // *
129
130 DeviceRuntimeParameterInt::DeviceRuntimeParameterInt(int iVal) {
131 this->iVal = iVal;
132 }
133
134 String DeviceRuntimeParameterInt::Type() {
135 return "INT";
136 }
137
138 bool DeviceRuntimeParameterInt::Multiplicity() {
139 return false;
140 }
141
142 optional<String> DeviceRuntimeParameterInt::RangeMin() {
143 optional<int> rangemin = RangeMinAsInt();
144 if (!rangemin) return optional<String>::nothing;
145 return ToString(*rangemin);
146 }
147
148 optional<String> DeviceRuntimeParameterInt::RangeMax() {
149 optional<int> rangemax = RangeMaxAsInt();
150 if (!rangemax) return optional<String>::nothing;
151 return ToString(*rangemax);
152 }
153
154 optional<String> DeviceRuntimeParameterInt::Possibilities() {
155 std::vector<int> possibilities = PossibilitiesAsInt();
156 if (possibilities.empty()) return optional<String>::nothing;
157
158 std::stringstream ss;
159 std::vector<int>::iterator iter = possibilities.begin();
160 while (iter != possibilities.end()) {
161 if (ss.str() != "") ss << ",";
162 ss << *iter;
163 iter++;
164 }
165 return ss.str();
166 }
167
168 String DeviceRuntimeParameterInt::Value() {
169 return ToString(ValueAsInt());
170 }
171
172 void DeviceRuntimeParameterInt::SetValue(String val) throw (LinuxSamplerException) {
173 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
174 int i = __parse_int(val);
175 if (RangeMinAsInt() && i < *RangeMinAsInt()) throw LinuxSamplerException("Invalid device parameter value: too small");
176 if (RangeMaxAsInt() && i > *RangeMaxAsInt()) throw LinuxSamplerException("Invalid device parameter value: too big");
177
178 std::vector<int> possibilities = PossibilitiesAsInt();
179 if (possibilities.size()) {
180 bool valid = false;
181 std::vector<int>::iterator iter = possibilities.begin();
182 while (iter != possibilities.end()) {
183 if (i == *iter) {
184 valid = true;
185 break;
186 }
187 iter++;
188 }
189 if (!valid) throw LinuxSamplerException("Invalid device parameter value: not in set of possible values");
190 }
191 OnSetValue(i);
192 SetValue(i);
193 }
194
195 int DeviceRuntimeParameterInt::ValueAsInt() {
196 return iVal;
197 }
198
199 void DeviceRuntimeParameterInt::SetValue(int i) {
200 iVal = i;
201 }
202
203
204
205 // *************** DeviceRuntimeParameterFloat ***************
206 // *
207
208 DeviceRuntimeParameterFloat::DeviceRuntimeParameterFloat(float fVal) {
209 this->fVal = fVal;
210 }
211
212 String DeviceRuntimeParameterFloat::Type() {
213 return "FLOAT";
214 }
215
216 bool DeviceRuntimeParameterFloat::Multiplicity() {
217 return false;
218 }
219
220 optional<String> DeviceRuntimeParameterFloat::RangeMin() {
221 optional<float> rangemin = RangeMinAsFloat();
222 if (!rangemin) return optional<String>::nothing;
223 return ToString(*rangemin);
224 }
225
226 optional<String> DeviceRuntimeParameterFloat::RangeMax() {
227 optional<float> rangemax = RangeMaxAsFloat();
228 if (!rangemax) return optional<String>::nothing;
229 return ToString(*rangemax);
230 }
231
232 optional<String> DeviceRuntimeParameterFloat::Possibilities() {
233 std::vector<float> possibilities = PossibilitiesAsFloat();
234 if (possibilities.empty()) return optional<String>::nothing;
235
236 std::stringstream ss;
237 std::vector<float>::iterator iter = possibilities.begin();
238 while (iter != possibilities.end()) {
239 if (ss.str() != "") ss << ",";
240 ss << *iter;
241 iter++;
242 }
243 return ss.str();
244 }
245
246 String DeviceRuntimeParameterFloat::Value() {
247 return ToString(ValueAsFloat());
248 }
249
250 void DeviceRuntimeParameterFloat::SetValue(String val) throw (LinuxSamplerException) {
251 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
252 float f = __parse_float(val);
253 if (RangeMinAsFloat() && f < *RangeMinAsFloat()) throw LinuxSamplerException("Invalid device parameter value: too small");
254 if (RangeMaxAsFloat() && f > *RangeMaxAsFloat()) throw LinuxSamplerException("Invalid device parameter value: too big");
255
256 std::vector<float> possibilities = PossibilitiesAsFloat();
257 if (possibilities.size()) {
258 bool valid = false;
259 std::vector<float>::iterator iter = possibilities.begin();
260 while (iter != possibilities.end()) {
261 if (f == *iter) {
262 valid = true;
263 break;
264 }
265 iter++;
266 }
267 if (!valid) throw LinuxSamplerException("Invalid device parameter value: not in set of possible values");
268 }
269 OnSetValue(f);
270 SetValue(f);
271 }
272
273 float DeviceRuntimeParameterFloat::ValueAsFloat() {
274 return fVal;
275 }
276
277 void DeviceRuntimeParameterFloat::SetValue(float f) {
278 fVal = f;
279 }
280
281
282
283 // *************** DeviceRuntimeParameterString ***************
284 // *
285
286 DeviceRuntimeParameterString::DeviceRuntimeParameterString(String sVal) {
287 this->sVal = sVal;
288 }
289
290 String DeviceRuntimeParameterString::Type() {
291 return "STRING";
292 }
293
294 bool DeviceRuntimeParameterString::Multiplicity() {
295 return false;
296 }
297
298 optional<String> DeviceRuntimeParameterString::RangeMin() {
299 return optional<String>::nothing;
300 }
301
302 optional<String> DeviceRuntimeParameterString::RangeMax() {
303 return optional<String>::nothing;
304 }
305
306 optional<String> DeviceRuntimeParameterString::Possibilities() {
307 std::vector<String> possibilities = PossibilitiesAsString();
308 if (possibilities.empty()) return optional<String>::nothing;
309
310 std::stringstream ss;
311 std::vector<String>::iterator iter = possibilities.begin();
312 while (iter != possibilities.end()) {
313 if (ss.str() != "") ss << ",";
314 ss << "'" << *iter << "'";
315 iter++;
316 }
317 return ss.str();
318 }
319
320 String DeviceRuntimeParameterString::Value() {
321 return sVal;
322 }
323
324 void DeviceRuntimeParameterString::SetValue(String val) throw (LinuxSamplerException) {
325 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
326 if (val.find("\'") != String::npos) throw LinuxSamplerException("Character -> \' <- not allowed");
327 if (val.find("\"") != String::npos) throw LinuxSamplerException("Character -> \" <- not allowed");
328 OnSetValue(val);
329 sVal = val;
330 }
331
332
333
334 // *************** DeviceRuntimeParameterStrings ***************
335 // *
336
337 DeviceRuntimeParameterStrings::DeviceRuntimeParameterStrings(std::vector<String> vS) {
338 this->sVals = vS;
339 }
340
341 String DeviceRuntimeParameterStrings::Type() {
342 return "STRING";
343 }
344
345 bool DeviceRuntimeParameterStrings::Multiplicity() {
346 return true;
347 }
348
349 optional<String> DeviceRuntimeParameterStrings::RangeMin() {
350 return optional<String>::nothing;
351 }
352
353 optional<String> DeviceRuntimeParameterStrings::RangeMax() {
354 return optional<String>::nothing;
355 }
356
357 optional<String> DeviceRuntimeParameterStrings::Possibilities() {
358 std::vector<String> possibilities = PossibilitiesAsString();
359 if (possibilities.empty()) return optional<String>::nothing;
360
361 std::stringstream ss;
362 std::vector<String>::iterator iter = possibilities.begin();
363 while (iter != possibilities.end()) {
364 if (ss.str() != "") ss << ",";
365 ss << "'" << *iter << "'";
366 iter++;
367 }
368 return ss.str();
369 }
370
371 String DeviceRuntimeParameterStrings::Value() {
372 String result;
373 std::vector<String>::iterator iter = this->sVals.begin();
374 while (iter != this->sVals.end()) {
375 if (result != "") result += ",";
376 result += "'" + *iter + "'";
377 iter++;
378 }
379 return result;
380 }
381
382 void DeviceRuntimeParameterStrings::SetValue(String val) throw (LinuxSamplerException) {
383 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
384 std::vector<String> vS = __parse_strings(val);
385 OnSetValue(vS);
386 SetValue(vS);
387 }
388
389 std::vector<String> DeviceRuntimeParameterStrings::ValueAsStrings() {
390 return sVals;
391 }
392
393 void DeviceRuntimeParameterStrings::SetValue(std::vector<String> vS) {
394 sVals = vS;
395 }
396
397
398
399
400
401
402 // *************** DeviceCreationParameter ***************
403 // *
404
405 optional<String> DeviceCreationParameter::Depends() {
406 std::map<String,DeviceCreationParameter*> dependencies = DependsAsParameters();
407 if (!dependencies.size()) return optional<String>::nothing;
408
409 std::map<String,DeviceCreationParameter*>::iterator iter = dependencies.begin();
410 String s;
411 for (; iter != dependencies.end(); iter++) {
412 if (s != "") s += ",";
413 s += iter->first;
414 }
415 return s;
416 }
417
418 optional<String> DeviceCreationParameter::Default() {
419 std::map<String,String> Parameters; // empty parameters vector
420 return Default(Parameters);
421 }
422
423 optional<String> DeviceCreationParameter::RangeMin() {
424 std::map<String,String> Parameters; // empty parameters vector
425 return RangeMin(Parameters);
426 }
427
428 optional<String> DeviceCreationParameter::RangeMax() {
429 std::map<String,String> Parameters; // empty parameters vector
430 return RangeMax(Parameters);
431 }
432
433 optional<String> DeviceCreationParameter::Possibilities() {
434 std::map<String,String> Parameters; // empty parameters vector
435 return Possibilities(Parameters);
436 }
437
438
439
440 // *************** DeviceCreationParameterBool ***************
441 // *
442
443 DeviceCreationParameterBool::DeviceCreationParameterBool() {
444 InitWithDefault();
445 }
446
447 DeviceCreationParameterBool::DeviceCreationParameterBool(bool bVal) {
448 this->bVal = bVal;
449 }
450
451 DeviceCreationParameterBool::DeviceCreationParameterBool(String val) throw (LinuxSamplerException) {
452 this->bVal = __parse_bool(val);
453 }
454
455 void DeviceCreationParameterBool::InitWithDefault() {
456 std::map<String,String> Parameters; // empty parameters vector
457 optional<bool> defaultval = DefaultAsBool(Parameters);
458 this->bVal = (defaultval) ? *defaultval : false;
459 }
460
461 String DeviceCreationParameterBool::Type() {
462 return "BOOL";
463 }
464
465 bool DeviceCreationParameterBool::Multiplicity() {
466 return false;
467 }
468
469 optional<String> DeviceCreationParameterBool::Default(std::map<String,String> Parameters) {
470 optional<bool> defaultval = DefaultAsBool(Parameters);
471 if (!defaultval) return optional<String>::nothing;
472 return (*defaultval) ? "TRUE" : "FALSE";
473 }
474
475 optional<String> DeviceCreationParameterBool::RangeMin(std::map<String,String> Parameters) {
476 return optional<String>::nothing;
477 }
478
479 optional<String> DeviceCreationParameterBool::RangeMax(std::map<String,String> Parameters) {
480 return optional<String>::nothing;
481 }
482
483 optional<String> DeviceCreationParameterBool::Possibilities(std::map<String,String> Parameters) {
484 return optional<String>::nothing;
485 }
486
487 String DeviceCreationParameterBool::Value() {
488 return (ValueAsBool()) ? "TRUE" : "FALSE";
489 }
490
491 void DeviceCreationParameterBool::SetValue(String val) throw (LinuxSamplerException) {
492 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
493 int b = __parse_bool(val);
494 OnSetValue(b);
495 SetValue(b);
496 }
497
498 bool DeviceCreationParameterBool::ValueAsBool() {
499 return bVal;
500 }
501
502 void DeviceCreationParameterBool::SetValue(bool b) {
503 bVal = b;
504 }
505
506
507
508 // *************** DeviceCreationParameterInt ***************
509 // *
510
511 DeviceCreationParameterInt::DeviceCreationParameterInt() {
512 InitWithDefault();
513 }
514
515 DeviceCreationParameterInt::DeviceCreationParameterInt(int iVal) {
516 this->iVal = iVal;
517 }
518
519 DeviceCreationParameterInt::DeviceCreationParameterInt(String val) throw (LinuxSamplerException) {
520 this->iVal = __parse_int(val);
521 }
522
523 void DeviceCreationParameterInt::InitWithDefault() {
524 std::map<String,String> Parameters; // empty parameters vector
525 optional<int> i = DefaultAsInt(Parameters);
526 this->iVal = (i) ? *i : 0;
527 }
528
529 String DeviceCreationParameterInt::Type() {
530 return "INT";
531 }
532
533 bool DeviceCreationParameterInt::Multiplicity() {
534 return false;
535 }
536
537 optional<String> DeviceCreationParameterInt::Default(std::map<String,String> Parameters) {
538 optional<int> defaultval = DefaultAsInt(Parameters);
539 if (!defaultval) return optional<String>::nothing;
540 return ToString(*defaultval);
541 }
542
543 optional<String> DeviceCreationParameterInt::RangeMin(std::map<String,String> Parameters) {
544 optional<int> rangemin = RangeMinAsInt(Parameters);
545 if (!rangemin) return optional<String>::nothing;
546 return ToString(rangemin);
547 }
548
549 optional<String> DeviceCreationParameterInt::RangeMax(std::map<String,String> Parameters) {
550 optional<int> rangemax = RangeMaxAsInt(Parameters);
551 if (!rangemax) return optional<String>::nothing;
552 return ToString(rangemax);
553 }
554
555 optional<String> DeviceCreationParameterInt::Possibilities(std::map<String,String> Parameters) {
556 std::vector<int> possibilities = PossibilitiesAsInt(Parameters);
557 if (possibilities.empty()) return optional<String>::nothing;
558
559 std::vector<int>::iterator iter = possibilities.begin();
560 std::stringstream ss;
561 while (iter != possibilities.end()) {
562 if (ss.str() != "") ss << ",";
563 ss << *iter;
564 iter++;
565 }
566 return ss.str();
567 }
568
569 String DeviceCreationParameterInt::Value() {
570 return ToString(ValueAsInt());
571 }
572
573 void DeviceCreationParameterInt::SetValue(String val) throw (LinuxSamplerException) {
574 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
575 int i = __parse_int(val);
576 //if (RangeMinAsInt() && i < *RangeMinAsInt()) throw LinuxSamplerException("Invalid device parameter value: too small");
577 //if (RangeMaxAsInt() && i > *RangeMaxAsInt()) throw LinuxSamplerException("Invalid device parameter value: too big");
578 /*if (PossibilitiesAsInt()) {
579 bool valid = false;
580 std::vector<int>* pPossibilities = PossibilitiesAsInt();
581 std::vector<int>::iterator iter = pPossibilities->begin();
582 while (iter != pPossibilities->end()) {
583 if (i == *iter) {
584 valid = true;
585 break;
586 }
587 iter++;
588 }
589 if (!valid) throw LinuxSamplerException("Invalid Device parameter value: not in set of possible values");
590 }*/
591 OnSetValue(i);
592 SetValue(i);
593 }
594
595 int DeviceCreationParameterInt::ValueAsInt() {
596 return iVal;
597 }
598
599 void DeviceCreationParameterInt::SetValue(int i) {
600 iVal = i;
601 }
602
603
604
605 // *************** DeviceCreationParameterFloat ***************
606 // *
607
608 DeviceCreationParameterFloat::DeviceCreationParameterFloat() {
609 InitWithDefault();
610 }
611
612 DeviceCreationParameterFloat::DeviceCreationParameterFloat(float fVal) {
613 this->fVal = fVal;
614 }
615
616 DeviceCreationParameterFloat::DeviceCreationParameterFloat(String val) throw (LinuxSamplerException) {
617 this->fVal = __parse_float(val);
618 }
619
620 void DeviceCreationParameterFloat::InitWithDefault() {
621 std::map<String,String> Parameters; // empty parameters vector
622 optional<float> f = DefaultAsFloat(Parameters);
623 this->fVal = (f) ? *f : 0.0f;
624 }
625
626 String DeviceCreationParameterFloat::Type() {
627 return "FLOAT";
628 }
629
630 bool DeviceCreationParameterFloat::Multiplicity() {
631 return false;
632 }
633
634 optional<String> DeviceCreationParameterFloat::Default(std::map<String,String> Parameters) {
635 optional<float> defaultval = DefaultAsFloat(Parameters);
636 if (!defaultval) return optional<String>::nothing;
637 return ToString(*defaultval);
638 }
639
640 optional<String> DeviceCreationParameterFloat::RangeMin(std::map<String,String> Parameters) {
641 optional<float> rangemin = RangeMinAsFloat(Parameters);
642 if (!rangemin) return optional<String>::nothing;
643 return ToString(*rangemin);
644 }
645
646 optional<String> DeviceCreationParameterFloat::RangeMax(std::map<String,String> Parameters) {
647 optional<float> rangemax = RangeMaxAsFloat(Parameters);
648 if (!rangemax) return optional<String>::nothing;
649 return ToString(*rangemax);
650 }
651
652 optional<String> DeviceCreationParameterFloat::Possibilities(std::map<String,String> Parameters) {
653 std::vector<float> possibilities = PossibilitiesAsFloat(Parameters);
654 if (possibilities.empty()) return optional<String>::nothing;
655
656 std::vector<float>::iterator iter = possibilities.begin();
657 std::stringstream ss;
658 while (iter != possibilities.end()) {
659 if (ss.str() != "") ss << ",";
660 ss << *iter;
661 iter++;
662 }
663 return ss.str();
664 }
665
666 String DeviceCreationParameterFloat::Value() {
667 return ToString(ValueAsFloat());
668 }
669
670 void DeviceCreationParameterFloat::SetValue(String val) throw (LinuxSamplerException) {
671 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
672 float f = __parse_float(val);
673 //if (RangeMinAsFloat() && i < *RangeMinAsFloat()) throw LinuxSamplerException("Invalid device parameter value: too small");
674 //if (RangeMaxAsFloat() && i > *RangeMaxAsFloat()) throw LinuxSamplerException("Invalid device parameter value: too big");
675 /*if (PossibilitiesAsFloat()) {
676 bool valid = false;
677 std::vector<float>* pPossibilities = PossibilitiesAsFloat();
678 std::vector<float>::iterator iter = pPossibilities->begin();
679 while (iter != pPossibilities->end()) {
680 if (f == *iter) {
681 valid = true;
682 break;
683 }
684 iter++;
685 }
686 if (!valid) throw LinuxSamplerException("Invalid Device parameter value: not in set of possible values");
687 }*/
688 OnSetValue(f);
689 SetValue(f);
690 }
691
692 float DeviceCreationParameterFloat::ValueAsFloat() {
693 return fVal;
694 }
695
696 void DeviceCreationParameterFloat::SetValue(float f) {
697 fVal = f;
698 }
699
700
701
702 // *************** DeviceCreationParameterString ***************
703 // *
704
705 DeviceCreationParameterString::DeviceCreationParameterString() {
706 InitWithDefault();
707 }
708
709 DeviceCreationParameterString::DeviceCreationParameterString(String sVal) {
710 this->sVal = sVal;
711 }
712
713 void DeviceCreationParameterString::InitWithDefault() {
714 std::map<String,String> Parameters; // empty parameters vector
715 optional<String> defaulval = Default(Parameters);
716 if (defaulval) this->sVal = *defaulval;
717 else this->sVal = "";
718 }
719
720 String DeviceCreationParameterString::Type() {
721 return "STRING";
722 }
723
724 bool DeviceCreationParameterString::Multiplicity() {
725 return false;
726 }
727
728 optional<String> DeviceCreationParameterString::RangeMin(std::map<String,String> Parameters) {
729 return optional<String>::nothing;
730 }
731
732 optional<String> DeviceCreationParameterString::RangeMax(std::map<String,String> Parameters) {
733 return optional<String>::nothing;
734 }
735
736 optional<String> DeviceCreationParameterString::Possibilities(std::map<String,String> Parameters) {
737 std::vector<String> possibilities = PossibilitiesAsString(Parameters);
738 if (possibilities.empty()) return optional<String>::nothing;
739
740 std::stringstream ss;
741 std::vector<String>::iterator iter = possibilities.begin();
742 while (iter != possibilities.end()) {
743 if (ss.str() != "") ss << ",";
744 ss << "'" << *iter << "'";
745 iter++;
746 }
747 return ss.str();
748 }
749
750 String DeviceCreationParameterString::Value() {
751 return sVal;
752 }
753
754 void DeviceCreationParameterString::SetValue(String val) throw (LinuxSamplerException) {
755 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
756 if (val.find("\'") != String::npos) throw LinuxSamplerException("Character -> \' <- not allowed");
757 if (val.find("\"") != String::npos) throw LinuxSamplerException("Character -> \" <- not allowed");
758 OnSetValue(val);
759 sVal = val;
760 }
761
762
763
764 // *************** DeviceCreationParameterStrings ***************
765 // *
766
767 DeviceCreationParameterStrings::DeviceCreationParameterStrings() {
768 InitWithDefault();
769 }
770
771 DeviceCreationParameterStrings::DeviceCreationParameterStrings(std::vector<String> sVals) {
772 this->sVals = sVals;
773 }
774
775 DeviceCreationParameterStrings::DeviceCreationParameterStrings(String val) throw (LinuxSamplerException) {
776 this->sVals = __parse_strings(val);
777 }
778
779 void DeviceCreationParameterStrings::InitWithDefault() {
780 std::map<String,String> Parameters; // empty parameters vector
781 optional<std::vector<String> > defaultval = DefaultAsStrings(Parameters);
782 this->sVals = (defaultval) ? *defaultval : std::vector<String>();
783 }
784
785 String DeviceCreationParameterStrings::Type() {
786 return "STRING";
787 }
788
789 bool DeviceCreationParameterStrings::Multiplicity() {
790 return true;
791 }
792
793 optional<String> DeviceCreationParameterStrings::RangeMin(std::map<String,String> Parameters) {
794 return optional<String>::nothing;
795 }
796
797 optional<String> DeviceCreationParameterStrings::RangeMax(std::map<String,String> Parameters) {
798 return optional<String>::nothing;
799 }
800
801 optional<String> DeviceCreationParameterStrings::Possibilities(std::map<String,String> Parameters) {
802 std::vector<String> possibilities = PossibilitiesAsString(Parameters);
803 if (possibilities.empty()) return optional<String>::nothing;
804
805 std::stringstream ss;
806 std::vector<String>::iterator iter = possibilities.begin();
807 while (iter != possibilities.end()) {
808 if (ss.str() != "") ss << ",";
809 ss << "'" << *iter << "'";
810 iter++;
811 }
812 return ss.str();
813 }
814
815 String DeviceCreationParameterStrings::Value() {
816 String result;
817 std::vector<String>::iterator iter = this->sVals.begin();
818 while (iter != this->sVals.end()) {
819 if (result != "") result += ",";
820 result += "'" + *iter + "'";
821 iter++;
822 }
823 return result;
824 }
825
826 void DeviceCreationParameterStrings::SetValue(String val) throw (LinuxSamplerException) {
827 if (Fix()) throw LinuxSamplerException("Device parameter is read only");
828 std::vector<String> vS = __parse_strings(val);
829 OnSetValue(vS);
830 SetValue(vS);
831 }
832
833 std::vector<String> DeviceCreationParameterStrings::ValueAsStrings() {
834 return sVals;
835 }
836
837 void DeviceCreationParameterStrings::SetValue(std::vector<String> vS) {
838 sVals = vS;
839 }
840
841 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC