CSettingsInterface.cpp

Go to the documentation of this file.
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         // Add the param to the map
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         // Add the param to the map
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         // Add the param to the map
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         // Add the param to the map
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         // Look up if the parameter exists
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                                 // Check the int map
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                                 // Check the int map
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                                 // Check the int map
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         // if so, look up the type:
00181         return S_OK;
00182 }
00183 
00184 STDMETHODIMP CSettingsInterface::SetParameter( const char* type, const char* value )
00185 {
00186         // Find out which group it's in
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                                 // Check if the parameter exists
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                                 // Check if the parameter exists
00216                                 if (m_intParams.contains(sParamName))
00217                                 {
00218                                         // Get int value
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                                 // Allow 0, 1, TRUE, true, FALSE and false
00231                                 // Check if the parameter exists
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                                 // Allow 0, 1, TRUE, true, FALSE and false
00246                                 // Check if the parameter exists
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         // Iterate over all the different params and display their current values
00266         std::string sResult;
00267 
00268         // Iterate over ints
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         // Iterate over chars
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         // Iterate over bool
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         // Iterate over double
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         // TODO: bools and doubles
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         // Buffer is too small
00310         return E_FAIL;
00311 }
00312 
00313 bool CSettingsInterface::revertParameter( const char* type )
00314 {
00315         // Find out which group it's in
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                                 // Check if the parameter exists
00327                                 if (m_stringParams.contains(sParamName))
00328                                 {
00329                                         return m_stringParams.revertToPreviousValue(sParamName);
00330                                 }
00331                                 return false;
00332                         }
00333                 case RTVC_INT:
00334                         {
00335                                 // Check if the parameter exists
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 }

Generated on Fri Mar 13 14:12:38 2009 for RTVC by  doxygen 1.5.3