void SettingsFile::ProcessVariable(const std::string& line, const std::string& file_name, const unsigned int& line_number) { ASSERT(line.length() >= 2); // Looks for an equals sign ('=') on this line. const unsigned int separator = line.find_first_of('='); // Get the raw variable name. std::string name = line.substr(0, separator); // Make sure that the variable name is valid. CheckVariableName(name, file_name, line_number); // If this variable name already exists, then this is a bad variable name. if(integer_variables.find(name) != integer_variables.end() || string_variables.find(name) != string_variables.end()) { throw SettingsFile::SyntaxError(SettingsFile::SyntaxError::BAD_VARIABLE_NAME, file_name, line_number); } // This check prevents an std::out_of_range exception. If the separator is the last character // on this line, then the variable's value is malformed. if(separator == line.length() - 1) { throw SettingsFile::SyntaxError(SettingsFile::SyntaxError::BAD_VALUE, file_name, line_number); } // Get the raw variable value. std::string value = line.substr(separator + 1, line.npos); // Make sure that the variable value is valid. CheckVariableValue(value, file_name, line_number); // Add the variable name/pair to the map of settings. long integer_value = 0; if(IsIntegerValue(value, integer_value) == true) { // The value is an integer. integer_variables.insert(std::make_pair(name, integer_value)); } else { // The value is a string. string_variables.insert(std::make_pair(name, value)); } }
// ----------------------------------------------------------------------------- // CWPPushMessage::ParseContentType // ----------------------------------------------------------------------------- // void CWPPushMessage::ParseContentType( TLex8& aPointer ) { // Go through the whole content type header. while( !aPointer.Eos() ) { // Each parameter might be well-known (integer) or unknown (text) if( IsIntegerValue( aPointer ) ) { // For well-known parameters, the token is an integer value TUint paramToken( I64LOW( GetIntegerValue( aPointer ) ) ); // These are filled with results from parsing. TInt resultInteger( 0 ); TPtrC8 resultString; // Make sure paramToken fits into KParameterTypes table if( paramToken < sizeof(KParameterTypes)/sizeof(TParameterCodingType)) { // Get the coding and use it to determine how we should decode // the next parameter value. We actually ignore all results // except short integer (SEC) and text-value (MAC), but the // rest of the parameters have to be parsed anyway. TParameterCodingType coding( KParameterTypes[paramToken] ); switch( coding ) { case EQValue: GetQValue( aPointer ); break; case EWellKnownCharset: GetWellKnownCharset( aPointer ); break; case EVersionValue: GetVersionValue( aPointer ); break; case EIntegerValue: GetIntegerValue( aPointer ); break; case ETextString: GetTextString( aPointer ); break; case EFieldName: GetFieldName( aPointer ); break; case EShortInteger: resultInteger = GetShortInteger( aPointer ); break; case EConstrainedEncoding: GetConstrainedEncoding( aPointer ); break; case EDeltaSecondsValue: GetDeltaSecondsValue( aPointer ); break; case ENoValue: GetNoValue( aPointer ); break; case ETextValue: resultString.Set( GetTextValue( aPointer ) ); break; case EDateValue: GetDateValue( aPointer ); break; default: break; } // We have a result. We're actually only interested in // SEC and MAC parameters, so we save them here. switch( paramToken ) { case KWSPHeaderSEC: iSEC = resultInteger; break; case KWSPHeaderMAC: iMAC.Set( resultString ); break; default: break; } } } else { // Unknown parameter. Its name is in text, and the value // might be an integer or text. GetTokenText( aPointer ); if( IsIntegerValue( aPointer ) ) { GetIntegerValue( aPointer ); } else { GetTextValue( aPointer ); } } } }