00001
00034 #include "CSettingsInterface.h"
00035
00036 #include <Shared/StringUtil.h>
00037
00038 CSettingsInterface::CSettingsInterface(void)
00039 {;}
00040
00041 CSettingsInterface::~CSettingsInterface(void)
00042 {;}
00043
00044 void CSettingsInterface::addParameter( const char* szParamName, int* pAddr, int nDefaultValue, bool bReadOnly, std::vector<int> vAllowedValues)
00045 {
00046
00047 std::string sParamName(szParamName);
00048 m_mParamTypes[sParamName] = RTVC_INT;
00049 m_intParams.addParam(std::string(szParamName), pAddr, nDefaultValue, bReadOnly, vAllowedValues);
00050 }
00051
00052 void CSettingsInterface::addParameter( const char* szParamName, std::string* pAddr, std::string sDefaultValue, bool bReadOnly, std::vector<std::string> vAllowedValues )
00053 {
00054
00055 std::string sParamName(szParamName);
00056 m_mParamTypes[sParamName] = RTVC_STRING;
00057 m_stringParams.addParam(std::string(szParamName), pAddr, sDefaultValue, bReadOnly, vAllowedValues);
00058 }
00059
00060 void CSettingsInterface::addParameter( const char* szParamName, bool* pAddr, bool bDefaultValue, bool bReadOnly, std::vector<bool> vAllowedValues )
00061 {
00062
00063 std::string sParamName(szParamName);
00064 m_mParamTypes[sParamName] = RTVC_BOOL;
00065 m_boolParams.addParam(std::string(szParamName), pAddr, bDefaultValue, bReadOnly, vAllowedValues);
00066 }
00067
00068 void CSettingsInterface::addParameter( const char* szParamName, double* pAddr, double dDefaultValue, bool bReadOnly, std::vector<double> vAllowedValues )
00069 {
00070
00071 std::string sParamName(szParamName);
00072 m_mParamTypes[sParamName] = RTVC_DOUBLE;
00073 m_doubleParams.addParam(std::string(szParamName), pAddr, dDefaultValue, bReadOnly, vAllowedValues);
00074 }
00075
00076 STDMETHODIMP CSettingsInterface::GetParameter( const char* type, int nBufferSize, char* value, int* length )
00077 {
00078
00079
00080 PARAM_TYPE_MAP::iterator it = m_mParamTypes.find(std::string(type));
00081 if ( it == m_mParamTypes.end())
00082 {
00083 return E_FAIL;
00084 }
00085 else
00086 {
00087 std::string sParamName = std::string(type);
00088 RTVC_PARAM_TYPES eType = it->second;
00089 switch (eType)
00090 {
00091 case RTVC_STRING:
00092 {
00093 std::string* pValue = m_stringParams.getParamAddress(sParamName);
00094 if (pValue)
00095 {
00096 if (pValue->length() < nBufferSize)
00097 {
00098 memcpy(value, (void*)pValue->c_str(), pValue->length());
00099 *length = pValue->length();
00100 value[*length] = 0;
00101 return S_OK;
00102 }
00103 else
00104 {
00105 return E_OUTOFMEMORY;
00106 }
00107 }
00108 return E_FAIL;
00109 break;
00110 }
00111 case RTVC_INT:
00112 {
00113
00114 int* pValue = m_intParams.getParamAddress(sParamName);
00115 if (pValue)
00116 {
00117 std::string sValue = StringUtil::itos(*pValue);
00118 if (sValue.length() < nBufferSize)
00119 {
00120 memcpy(value, (void*)sValue.c_str(), sValue.length());
00121 *length = sValue.length();
00122 value[*length] = 0;
00123 return S_OK;
00124 }
00125 else
00126 {
00127 return E_OUTOFMEMORY;
00128 }
00129 }
00130 return E_FAIL;
00131 break;
00132 }
00133 case RTVC_BOOL:
00134 {
00135
00136 bool* pValue = m_boolParams.getParamAddress(sParamName);
00137 if (pValue)
00138 {
00139 std::string sValue = StringUtil::boolToString(*pValue);
00140 if (sValue.length() < nBufferSize)
00141 {
00142 memcpy(value, (void*)sValue.c_str(), sValue.length());
00143 *length = sValue.length();
00144 value[*length] = 0;
00145 return S_OK;
00146 }
00147 else
00148 {
00149 return E_OUTOFMEMORY;
00150 }
00151 }
00152 return E_FAIL;
00153 break;
00154 }
00155 case RTVC_DOUBLE:
00156 {
00157
00158 double* pValue = m_doubleParams.getParamAddress(sParamName);
00159 if (pValue)
00160 {
00161 std::string sValue = StringUtil::doubleToString(*pValue);
00162 if (sValue.length() < nBufferSize)
00163 {
00164 memcpy(value, (void*)sValue.c_str(), sValue.length());
00165 *length = sValue.length();
00166 value[*length] = 0;
00167 return S_OK;
00168 }
00169 else
00170 {
00171 return E_OUTOFMEMORY;
00172 }
00173 }
00174 return E_FAIL;
00175 break;
00176 }
00177 }
00178 }
00179
00180
00181 return S_OK;
00182 }
00183
00184 STDMETHODIMP CSettingsInterface::SetParameter( const char* type, const char* value )
00185 {
00186
00187 PARAM_TYPE_MAP::iterator it = m_mParamTypes.find(std::string(type));
00188 if ( it == m_mParamTypes.end())
00189 {
00190 return E_FAIL;
00191 }
00192 else
00193 {
00194 RTVC_PARAM_TYPES eType = it->second;
00195 std::string sParamName = type;
00196
00197 switch (eType)
00198 {
00199 case RTVC_STRING:
00200 {
00201
00202 if (m_stringParams.contains(sParamName))
00203 {
00204 std::string sValue(value);
00205 if (m_stringParams.setParameterValue(sParamName, sValue))
00206 {
00207 return S_OK;
00208 }
00209 }
00210 return E_FAIL;
00211 break;
00212 }
00213 case RTVC_INT:
00214 {
00215
00216 if (m_intParams.contains(sParamName))
00217 {
00218
00219 int nNewValue = atoi(value);
00220 if (m_intParams.setParameterValue(sParamName, nNewValue))
00221 {
00222 return S_OK;
00223 }
00224 }
00225 return E_FAIL;
00226 break;
00227 }
00228 case RTVC_BOOL:
00229 {
00230
00231
00232 if (m_boolParams.contains(sParamName))
00233 {
00234 bool bValue = StringUtil::stringToBool(std::string(value));
00235 if (m_boolParams.setParameterValue(sParamName, bValue))
00236 {
00237 return S_OK;
00238 }
00239 }
00240 return E_FAIL;
00241 break;
00242 }
00243 case RTVC_DOUBLE:
00244 {
00245
00246
00247 if (m_doubleParams.contains(sParamName))
00248 {
00249 double dValue = StringUtil::stringToDouble(std::string(value));
00250 if (m_doubleParams.setParameterValue(sParamName, dValue))
00251 {
00252 return S_OK;
00253 }
00254 }
00255 return E_FAIL;
00256 break;
00257 }
00258 }
00259 }
00260 return S_OK;
00261 }
00262
00263 STDMETHODIMP CSettingsInterface::GetParameterSettings( char* szResult, int nSize )
00264 {
00265
00266 std::string sResult;
00267
00268
00269 std::vector<std::string> vParams = m_intParams.getParameterNames();
00270 for (int i = 0; i < vParams.size(); i++)
00271 {
00272 int nValue = *(m_intParams.getParamAddress(vParams[i]));
00273 sResult += "Parameter name: " + vParams[i] + " Value: " + StringUtil::itos(nValue) + "\r\n";
00274 }
00275
00276
00277 vParams = m_stringParams.getParameterNames();
00278 for (int i = 0; i < vParams.size(); i++)
00279 {
00280 std::string sValue = *(m_stringParams.getParamAddress(vParams[i]));
00281 sResult += "Parameter name: " + vParams[i] + " Value: " + sValue + "\r\n";
00282 }
00283
00284
00285 vParams = m_boolParams.getParameterNames();
00286 for (int i = 0; i < vParams.size(); i++)
00287 {
00288 bool bValue = *(m_boolParams.getParamAddress(vParams[i]));
00289 std::string sValue = (bValue)?"true":"false";
00290 sResult += "Parameter name: " + vParams[i] + " Value: " + sValue + "\r\n";
00291 }
00292
00293
00294 vParams = m_doubleParams.getParameterNames();
00295 for (int i = 0; i < vParams.size(); i++)
00296 {
00297 double dValue = *(m_doubleParams.getParamAddress(vParams[i]));
00298 sResult += "Parameter name: " + vParams[i] + " Value: " + StringUtil::doubleToString(dValue) + "\r\n";
00299 }
00300
00301
00302
00303 if (sResult.length()< nSize)
00304 {
00305 memcpy(szResult, sResult.c_str(), sResult.length());
00306 szResult[sResult.length()] = 0;
00307 return S_OK;
00308 }
00309
00310 return E_FAIL;
00311 }
00312
00313 bool CSettingsInterface::revertParameter( const char* type )
00314 {
00315
00316 PARAM_TYPE_MAP::iterator it = m_mParamTypes.find(std::string(type));
00317 if ( it != m_mParamTypes.end())
00318 {
00319 RTVC_PARAM_TYPES eType = it->second;
00320 std::string sParamName = type;
00321
00322 switch (eType)
00323 {
00324 case RTVC_STRING:
00325 {
00326
00327 if (m_stringParams.contains(sParamName))
00328 {
00329 return m_stringParams.revertToPreviousValue(sParamName);
00330 }
00331 return false;
00332 }
00333 case RTVC_INT:
00334 {
00335
00336 if (m_intParams.contains(sParamName))
00337 {
00338 return m_intParams.revertToPreviousValue(sParamName);
00339 }
00340 return false;
00341 }
00342 case RTVC_BOOL:
00343 {
00344 if (m_boolParams.contains(sParamName))
00345 {
00346 return m_boolParams.revertToPreviousValue(sParamName);
00347 }
00348 return false;
00349 }
00350 case RTVC_DOUBLE:
00351 {
00352 if (m_doubleParams.contains(sParamName))
00353 {
00354 return m_doubleParams.revertToPreviousValue(sParamName);
00355 }
00356 return false;
00357 }
00358 }
00359 }
00360 return false;
00361 }