linuxsampler 1.0.0

DeviceParameter.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  *                                                                         *
00003  *   LinuxSampler - modular, streaming capable sampler                     *
00004  *                                                                         *
00005  *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
00006  *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *
00007  *                                                                         *
00008  *   This program is free software; you can redistribute it and/or modify  *
00009  *   it under the terms of the GNU General Public License as published by  *
00010  *   the Free Software Foundation; either version 2 of the License, or     *
00011  *   (at your option) any later version.                                   *
00012  *                                                                         *
00013  *   This program is distributed in the hope that it will be useful,       *
00014  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00015  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
00016  *   GNU General Public License for more details.                          *
00017  *                                                                         *
00018  *   You should have received a copy of the GNU General Public License     *
00019  *   along with this program; if not, write to the Free Software           *
00020  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00021  *   MA  02111-1307  USA                                                   *
00022  ***************************************************************************/
00023 
00024 #ifndef __LS_DEVICE_PARAMETER_H__
00025 #define __LS_DEVICE_PARAMETER_H__
00026 
00027 #include <map>
00028 #include <vector>
00029 
00030 #include "../common/global.h"
00031 #include "../common/optional.h"
00032 #include "../common/Exception.h"
00033 #include "Device.h"
00034 
00035 namespace LinuxSampler {
00036 
00037     // 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.
00038 
00039     class DeviceRuntimeParameter {
00040         public:
00041             virtual String           Type()          = 0;
00042             virtual String           Description()   = 0;
00043             virtual bool             Fix()           = 0;
00044             virtual bool             Multiplicity()  = 0;
00045             virtual optional<String> RangeMin()      = 0;
00046             virtual optional<String> RangeMax()      = 0;
00047             virtual optional<String> Possibilities() = 0;
00048             virtual String           Value()         = 0;
00049             virtual void             SetValue(String val) throw (Exception) = 0;
00050             virtual ~DeviceRuntimeParameter(){};
00051     };
00052 
00053     class DeviceRuntimeParameterBool : public DeviceRuntimeParameter {
00054         public:
00055             DeviceRuntimeParameterBool(bool bVal);
00056             virtual String           Type();
00057             virtual bool             Multiplicity();
00058             virtual optional<String> RangeMin();
00059             virtual optional<String> RangeMax();
00060             virtual optional<String> Possibilities();
00061             virtual String           Value();
00062             virtual void             SetValue(String val) throw (Exception);
00063 
00064             virtual bool ValueAsBool();
00065             virtual void SetValue(bool b) throw (Exception);
00066 
00067             virtual void OnSetValue(bool b) throw (Exception) = 0;
00068         protected:
00069             bool bVal;
00070     };
00071 
00072     class DeviceRuntimeParameterInt : public DeviceRuntimeParameter {
00073         public:
00074             DeviceRuntimeParameterInt(int iVal);
00075             virtual String           Type();
00076             virtual bool             Multiplicity();
00077             virtual optional<String> RangeMin();
00078             virtual optional<String> RangeMax();
00079             virtual optional<String> Possibilities();
00080             virtual String           Value();
00081             virtual void             SetValue(String val) throw (Exception);
00082 
00083             virtual int  ValueAsInt();
00084             virtual void SetValue(int i) throw (Exception);
00085 
00086             virtual optional<int>    RangeMinAsInt()      = 0;
00087             virtual optional<int>    RangeMaxAsInt()      = 0;
00088             virtual std::vector<int> PossibilitiesAsInt() = 0;
00089             virtual void             OnSetValue(int i) throw (Exception) = 0;
00090         protected:
00091             int iVal;
00092     };
00093 
00094     class DeviceRuntimeParameterFloat : public DeviceRuntimeParameter {
00095         public:
00096             DeviceRuntimeParameterFloat(float fVal);
00097             virtual String           Type();
00098             virtual bool             Multiplicity();
00099             virtual optional<String> RangeMin();
00100             virtual optional<String> RangeMax();
00101             virtual optional<String> Possibilities();
00102             virtual String           Value();
00103             virtual void             SetValue(String val) throw (Exception);
00104 
00105             virtual float ValueAsFloat();
00106             virtual void  SetValue(float f) throw (Exception);
00107 
00108             virtual optional<float>     RangeMinAsFloat()      = 0;
00109             virtual optional<float>     RangeMaxAsFloat()      = 0;
00110             virtual std::vector<float>  PossibilitiesAsFloat() = 0;
00111             virtual void                OnSetValue(float f) = 0;
00112         protected:
00113             float fVal;
00114     };
00115 
00116     class DeviceRuntimeParameterString : public DeviceRuntimeParameter {
00117         public:
00118             DeviceRuntimeParameterString(String sVal);
00119             virtual ~DeviceRuntimeParameterString(){}
00120             virtual String           Type();
00121             virtual bool             Multiplicity();
00122             virtual optional<String> RangeMin();
00123             virtual optional<String> RangeMax();
00124             virtual optional<String> Possibilities();
00125             virtual String           Value();
00126             virtual void             SetValue(String val) throw (Exception);
00127 
00128             virtual String ValueAsString();
00129             virtual void   SetValueAsString(String s) throw (Exception);
00130 
00131             virtual std::vector<String> PossibilitiesAsString() = 0;
00132             virtual void                OnSetValue(String s)    = 0;
00133         protected:
00134             String sVal;
00135     };
00136 
00137     class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
00138         public:
00139             DeviceRuntimeParameterStrings(std::vector<String> vS);
00140             virtual ~DeviceRuntimeParameterStrings(){}
00141             virtual String           Type();
00142             virtual bool             Multiplicity();
00143             virtual optional<String> RangeMin();
00144             virtual optional<String> RangeMax();
00145             virtual optional<String> Possibilities();
00146             virtual String           Value();
00147             virtual void             SetValue(String val) throw (Exception);
00148 
00149             virtual std::vector<String> ValueAsStrings();
00150             virtual void                SetValue(std::vector<String> vS) throw (Exception);
00151 
00152             virtual std::vector<String> PossibilitiesAsString()            = 0;
00153             virtual void                OnSetValue(std::vector<String> vS) = 0;
00154         protected:
00155             std::vector<String> sVals;
00156     };
00157 
00158 
00159 
00160     class DeviceCreationParameter : public DeviceRuntimeParameter {
00161         public:
00162             DeviceCreationParameter ( void )                  { pDevice = NULL; }
00163             virtual bool                                      Mandatory() = 0;
00164             virtual optional<String>                          Depends();
00165             virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
00166             virtual optional<String>                          Default();
00167             virtual optional<String>                          Default(std::map<String,String> Parameters) = 0;
00168             virtual optional<String>                          RangeMin();
00169             virtual optional<String>                          RangeMin(std::map<String,String> Parameters) = 0;
00170             virtual optional<String>                          RangeMax();
00171             virtual optional<String>                          RangeMax(std::map<String,String> Parameters) = 0;
00172             virtual optional<String>                          Possibilities();
00173             virtual optional<String>                          Possibilities(std::map<String,String> Parameters) = 0;
00174             void                                              Attach(Device* pDevice) { this->pDevice = pDevice; }
00175         protected:
00176             Device* pDevice;
00177     };
00178 
00179     class DeviceCreationParameterBool : public DeviceCreationParameter {
00180         public:
00181             DeviceCreationParameterBool(bool bVal = false);
00182             DeviceCreationParameterBool(String val) throw (Exception);
00183             virtual String Type();
00184             virtual bool   Multiplicity();
00185             virtual optional<String> Default(std::map<String,String> Parameters);
00186             virtual optional<String> RangeMin(std::map<String,String> Parameters);
00187             virtual optional<String> RangeMax(std::map<String,String> Parameters);
00188             virtual optional<String> Possibilities(std::map<String,String> Parameters);
00189             virtual String Value();
00190             virtual void   SetValue(String val) throw (Exception);
00191 
00192             virtual bool ValueAsBool();
00193             virtual void SetValue(bool b) throw (Exception);
00194 
00195             virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
00196             virtual void OnSetValue(bool b) throw (Exception)  = 0;
00197         protected:
00198             bool bVal;
00199             void InitWithDefault();
00200         private:
00201     };
00202 
00203     class DeviceCreationParameterInt : public DeviceCreationParameter {
00204         public:
00205             DeviceCreationParameterInt(int iVal = 0);
00206             DeviceCreationParameterInt(String val) throw (Exception);
00207             virtual String Type();
00208             virtual bool   Multiplicity();
00209             virtual optional<String> Default(std::map<String,String> Parameters);
00210             virtual optional<String> RangeMin(std::map<String,String> Parameters);
00211             virtual optional<String> RangeMax(std::map<String,String> Parameters);
00212             virtual optional<String> Possibilities(std::map<String,String> Parameters);
00213             virtual String Value();
00214             virtual void   SetValue(String val) throw (Exception);
00215 
00216             virtual int  ValueAsInt();
00217             virtual void SetValue(int i) throw (Exception);
00218 
00219             virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters)  = 0;
00220             virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters) = 0;
00221             virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters) = 0;
00222             virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
00223             virtual void             OnSetValue(int i) throw (Exception)  = 0;
00224         protected:
00225             int iVal;
00226             void InitWithDefault();
00227         private:
00228     };
00229 
00230     class DeviceCreationParameterFloat : public DeviceCreationParameter {
00231         public:
00232             DeviceCreationParameterFloat(float fVal = 0.0);
00233             DeviceCreationParameterFloat(String val) throw (Exception);
00234             virtual String Type();
00235             virtual bool   Multiplicity();
00236             virtual optional<String> Default(std::map<String,String> Parameters);
00237             virtual optional<String> RangeMin(std::map<String,String> Parameters);
00238             virtual optional<String> RangeMax(std::map<String,String> Parameters);
00239             virtual optional<String> Possibilities(std::map<String,String> Parameters);
00240             virtual String Value();
00241             virtual void   SetValue(String val) throw (Exception);
00242 
00243             virtual float ValueAsFloat();
00244             virtual void  SetValue(float f) throw (Exception);
00245 
00246             virtual optional<float>    DefaultAsFloat(std::map<String,String> Parameters)  = 0;
00247             virtual optional<float>    RangeMinAsFloat(std::map<String,String> Parameters) = 0;
00248             virtual optional<float>    RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
00249             virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
00250             virtual void OnSetValue(float f) throw (Exception)  = 0;
00251         protected:
00252             float fVal;
00253             void InitWithDefault();
00254         private:
00255     };
00256 
00257     class DeviceCreationParameterString : public DeviceCreationParameter {
00258         public:
00259             DeviceCreationParameterString(String sVal = String());
00260             virtual ~DeviceCreationParameterString(){}
00261             virtual String Type();
00262             virtual bool   Multiplicity();
00263             virtual optional<String> Default(std::map<String,String> Parameters);
00264             virtual optional<String> RangeMin(std::map<String,String> Parameters);
00265             virtual optional<String> RangeMax(std::map<String,String> Parameters);
00266             virtual optional<String> Possibilities(std::map<String,String> Parameters);
00267             virtual String Value();
00268             virtual void   SetValue(String val) throw (Exception);
00269 
00270             virtual String ValueAsString();
00271             virtual void   SetValueAsString(String s) throw (Exception);
00272 
00273             virtual optional<String>    DefaultAsString(std::map<String,String> Parameters) = 0;
00274             virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
00275             virtual void OnSetValue(String s) throw (Exception) = 0;
00276         protected:
00277             String sVal;
00278             void InitWithDefault();
00279         private:
00280     };
00281 
00282     class DeviceCreationParameterStrings : public DeviceCreationParameter {
00283         public:
00284             DeviceCreationParameterStrings();
00285             DeviceCreationParameterStrings(std::vector<String> sVals);
00286             DeviceCreationParameterStrings(String val) throw (Exception);
00287             virtual ~DeviceCreationParameterStrings(){}
00288             virtual String Type();
00289             virtual bool   Multiplicity();
00290             virtual optional<String> Default(std::map<String,String> Parameters);
00291             virtual optional<String> RangeMin(std::map<String,String> Parameters);
00292             virtual optional<String> RangeMax(std::map<String,String> Parameters);
00293             virtual optional<String> Possibilities(std::map<String,String> Parameters);
00294             virtual String Value();
00295             virtual void   SetValue(String val) throw (Exception);
00296 
00297             virtual std::vector<String> ValueAsStrings();
00298             virtual void                SetValue(std::vector<String> vS) throw (Exception);
00299 
00300             virtual std::vector<String> DefaultAsStrings(std::map<String,String> Parameters) = 0;
00301             virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
00302             virtual void OnSetValue(std::vector<String> vS) throw (Exception) = 0;
00303         protected:
00304             std::vector<String> sVals;
00305             void InitWithDefault();
00306         private:
00307     };
00308 
00309 } // namespace LinuxSampler
00310 
00311 #endif // __LS_DEVICE_PARAMETER_H__