Properties parseToPropertiesMap(std::istream& file) { Properties properties; std::string line; while (safeGetline(file, line)) { line = stripComments(line); boost::char_separator<char> sep("="); boost::tokenizer<boost::char_separator<char>> tok(line, sep); auto word = tok.begin(); if (word == tok.end()) { continue; } std::string key = stripWhitespace(*word); if (key == "") { continue; } if (++word == tok.end()) { continue; } std::string value = stripWhitespace(*word); properties[key] = value; } return properties; }
void processGoalie(Game* game, League* league, std::string rawGoalieString, bool done){ /* Initialize values to their default states */ std::string gID = game->id; std::string tID="null"; int player = 0; int shots = 0; int goals = 0; int seconds = 0; player = std::stoi(split(split(rawGoalieString, "playerid=")[1], "&")[0]); std::vector<std::string> items = split(rawGoalieString, "</td>"); items.erase(items.begin()); for(int i = 0; i < items.size(); i++){ items[i] = extract(items[i]+"</td>", "td"); } if(stripWhitespace(items[0]) == "") return; seconds = std::stoi(stripWhitespace(items[0])); shots = std::stoi(stripWhitespace(items[1])); goals = shots - std::stoi(stripWhitespace(items[2])); tID = league->getPlayer(player)->teamID; league->setGoaliePerformance(gID, tID, player, seconds, goals, shots); if(done){ Player* p = league->getPlayer(player); p->gamesPlayed++; p->shots += shots; p->goalsAgainst += goals; p->minutesPlayed += seconds; p->saves += shots-goals; if(p->gamesPlayed == 0){ p->goalsAgainstAverage = 0; }else{ p->goalsAgainstAverage = p->goalsAgainst*1.0/p->gamesPlayed; } if(p->shots == 0){ p->savePercentage = 0; }else{ p->savePercentage = p->saves*1.0/p->shots; } std::cout<<"Updating Goalie \n"; db_updatePlayer(p, league); std::cout<<"Successfully finished updating goalie\n"; } }
std::size_t ShaderParser::parseDepthSettings(std::size_t startIndex) { std::string resultingSource; std::size_t endIndex = parseSourceFrom(startIndex, resultingSource); resultingSource = stripWhitespace(resultingSource); compileSettingParameter(myDepthSettings.enabled, resultingSource, "enabled"); compileSettingsParameter(myDepthSettings.function, resultingSource, "function"); return endIndex; }
std::size_t ShaderParser::parseBlendSettings(std::size_t startIndex) { std::string resultingSource; std::size_t endIndex = parseSourceFrom(startIndex, resultingSource); resultingSource = stripWhitespace(resultingSource); compileSettingParameter(myBlendSettings.enabled, resultingSource, "enabled"); compileSettingsParameter(myBlendSettings.sourceFactor, resultingSource, "sourceFactor"); compileSettingsParameter(myBlendSettings.destinationFactor, resultingSource, "destinationFactor"); compileSettingsParameter(myBlendSettings.function, resultingSource, "function"); return endIndex; }
/* Returns whether a sequence of chars is empty or not */ LATBool isSequenceEmpty(char *input) { char *tmp = stripWhitespace(input); while(*tmp) { if(*tmp != '\n' && *tmp != '\r' && *tmp != '\t') { return false; } tmp++; } return true; }
static int testJSONSnippet( const char * benc_str, const char * expected ) { tr_benc top; char * serialized; tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL ); serialized = tr_bencSaveAsJSON( &top, NULL ); stripWhitespace( serialized ); #if 0 fprintf( stderr, "benc: %s\n", benc_str ); fprintf( stderr, "json: %s\n", serialized ); fprintf( stderr, "want: %s\n", expected ); #endif check( !strcmp( serialized, expected ) ); tr_free( serialized ); tr_bencFree( &top ); return 0; }
/* func: inputString in: prompt (const char*) - prompt to display size (size_t) - max size of input string INCLUDING null terminator out: pointer to input string (char) desc: prompts user, then uses fgets() to input a string; truncates and discards any input after size chars */ char *inputString(const char *prompt, int size) { char *in = malloc(size); int i = 0; char c = 0; printf("%s", prompt); fgets(in, size, stdin); // get a line for (i = 0; i < size; i++) // look for newline (if not found, we've overrun) if (in[i] == '\n') c = !(in[i] = 0); // using c as temp flag to skip getchar() if newline found // if we didn't find newline, flush overrun chars if (c == 0) while ((c = getchar()) != '\n' && c != 0); // remove whitespace from beginning and end of string stripWhitespace(in); return in; }
static int testJSONSnippet( const char * benc_str, const char * expected ) { tr_benc top; char * serialized; struct evbuffer * buf; tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL ); buf = tr_bencToBuf( &top, TR_FMT_JSON ); serialized = (char*) evbuffer_pullup( buf, -1 ); stripWhitespace( serialized ); #if 0 fprintf( stderr, "benc: %s\n", benc_str ); fprintf( stderr, "json: %s\n", serialized ); fprintf( stderr, "want: %s\n", expected ); #endif check_streq (expected, serialized); tr_bencFree( &top ); evbuffer_free( buf ); return 0; }
void RuleBasedNumberFormat::init(const UnicodeString& rules, LocalizationInfo* localizationInfos, UParseError& pErr, UErrorCode& status) { // TODO: implement UParseError uprv_memset(&pErr, 0, sizeof(UParseError)); // Note: this can leave ruleSets == NULL, so remaining code should check if (U_FAILURE(status)) { return; } this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref(); UnicodeString description(rules); if (!description.length()) { status = U_MEMORY_ALLOCATION_ERROR; return; } // start by stripping the trailing whitespace from all the rules // (this is all the whitespace follwing each semicolon in the // description). This allows us to look for rule-set boundaries // by searching for ";%" without having to worry about whitespace // between the ; and the % stripWhitespace(description); // check to see if there's a set of lenient-parse rules. If there // is, pull them out into our temporary holding place for them, // and delete them from the description before the real desciption- // parsing code sees them int32_t lp = description.indexOf(gLenientParse, -1, 0); if (lp != -1) { // we've got to make sure we're not in the middle of a rule // (where "%%lenient-parse" would actually get treated as // rule text) if (lp == 0 || description.charAt(lp - 1) == gSemiColon) { // locate the beginning and end of the actual collation // rules (there may be whitespace between the name and // the first token in the description) int lpEnd = description.indexOf(gSemiPercent, 2, lp); if (lpEnd == -1) { lpEnd = description.length() - 1; } int lpStart = lp + u_strlen(gLenientParse); while (PatternProps::isWhiteSpace(description.charAt(lpStart))) { ++lpStart; } // copy out the lenient-parse rules and delete them // from the description lenientParseRules = new UnicodeString(); /* test for NULL */ if (lenientParseRules == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } lenientParseRules->setTo(description, lpStart, lpEnd - lpStart); description.remove(lp, lpEnd + 1 - lp); } } // pre-flight parsing the description and count the number of // rule sets (";%" marks the end of one rule set and the beginning // of the next) numRuleSets = 0; for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, p)) { ++numRuleSets; ++p; } ++numRuleSets; // our rule list is an array of the appropriate size ruleSets = (NFRuleSet **)uprv_malloc((numRuleSets + 1) * sizeof(NFRuleSet *)); /* test for NULL */ if (ruleSets == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } for (int i = 0; i <= numRuleSets; ++i) { ruleSets[i] = NULL; } // divide up the descriptions into individual rule-set descriptions // and store them in a temporary array. At each step, we also // new up a rule set, but all this does is initialize its name // and remove it from its description. We can't actually parse // the rest of the descriptions and finish initializing everything // because we have to know the names and locations of all the rule // sets before we can actually set everything up if(!numRuleSets) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } ruleSetDescriptions = new UnicodeString[numRuleSets]; if (ruleSetDescriptions == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } { int curRuleSet = 0; int32_t start = 0; for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, start)) { ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start); ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status); if (ruleSets[curRuleSet] == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } ++curRuleSet; start = p + 1; } ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start); ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status); if (ruleSets[curRuleSet] == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } } // now we can take note of the formatter's default rule set, which // is the last public rule set in the description (it's the last // rather than the first so that a user can create a new formatter // from an existing formatter and change its default behavior just // by appending more rule sets to the end) // {dlf} Initialization of a fraction rule set requires the default rule // set to be known. For purposes of initialization, this is always the // last public rule set, no matter what the localization data says. initDefaultRuleSet(); // finally, we can go back through the temporary descriptions // list and finish seting up the substructure (and we throw // away the temporary descriptions as we go) { for (int i = 0; i < numRuleSets; i++) { ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status); } } // Now that the rules are initialized, the 'real' default rule // set can be adjusted by the localization data. // The C code keeps the localization array as is, rather than building // a separate array of the public rule set names, so we have less work // to do here-- but we still need to check the names. if (localizationInfos) { // confirm the names, if any aren't in the rules, that's an error // it is ok if the rules contain public rule sets that are not in this list for (int32_t i = 0; i < localizationInfos->getNumberOfRuleSets(); ++i) { UnicodeString name(TRUE, localizationInfos->getRuleSetName(i), -1); NFRuleSet* rs = findRuleSet(name, status); if (rs == NULL) { break; // error } if (i == 0) { defaultRuleSet = rs; } } } else { defaultRuleSet = getDefaultRuleSet(); } }
TEST(TextTest, test_stripWhitespace) { std::string s("foo \n"); stripWhitespace(s); EXPECT_EQ("foo", s); }