void Token::constructTerms() {
string aux;
iterador = candidates.begin();
while (iterador != candidates.end()) {
aux = trim_copy(*iterador, " \'{}[]-+.,*/%$?<>=^#&!_`");
aux = replaceMultiByteChars(aux, '_');
if (!isdigit(aux[0]))
aux = caseNotDigit(aux);
else
if ((isdigit(aux[0])))
aux = caseDigit(aux);
aux = trim_copy(aux, " @\'{}[]-+.*/?<>=^$%#&!_");
if (aux == "") {
iterador = candidates.erase(iterador);
} else {
string_type tipo = whatIsIt(aux);
if ((tipo == ALPHANUMERIC1) || (tipo == TEXT)) {
stringToLower(aux);
stemOfPlural(aux);
}
*iterador = aux;
iterador++;
}
}
iterador = candidates.begin();
_currentPosition = 0;
_count = candidates.size();
}
Status ComplexQuery::parse_expression(const string& exp) {
static const string OPCHAR = "=!<>";
CHECK(!exp.empty());
size_t op_pos = exp.find_first_of(OPCHAR);
if (op_pos == string::npos) {
return Status(-1, "Bad expression.");
}
size_t value_pos = exp.find_first_not_of(OPCHAR, op_pos);
if (value_pos == string::npos) {
return Status(-1, "Bad expression.");
}
string field = trim_copy(exp.substr(0, op_pos));
string opstr = exp.substr(op_pos, value_pos - op_pos);
string value = trim_copy(exp.substr(value_pos));
int op = parse_cond_op(opstr);
if (op < 0) {
return Status(-1, "Bad operation.");
}
string tmp(value);
Status status = parse_value(field, tmp, &value);
if (!status.ok()) {
LOG(ERROR) << status.message() << ":" << tmp;
return status;
}
switch (op) {
case LE:
range_query_map_[field].upper = value;
range_query_map_[field].upper_closed = true;
break;
case LT:
range_query_map_[field].upper = value;
range_query_map_[field].upper_closed = false;
break;
case GE:
range_query_map_[field].lower = value;
range_query_map_[field].lower_closed = true;
break;
case GT:
range_query_map_[field].lower = value;
range_query_map_[field].lower_closed = false;
break;
case EQ:
range_query_map_[field].upper = value;
range_query_map_[field].upper_closed = true;
range_query_map_[field].lower = value;
range_query_map_[field].lower_closed = true;
break;
default:
LOG(ERROR) << "Unknown op code: " << opstr;
return Status(-1, "Unknown op code.");
}
return Status::OK;
}
string SuperiorValueInterfaceElement::display(
ostream& stream
, const ParametersVector& parameters
, interfaces::VariablesMap& variables
, const void* object
, const server::Request* request) const
{
stream << ((
lexical_cast<RegistryKeyType>(trim_copy(_left->getValue(parameters, variables, object, request))) >
lexical_cast<RegistryKeyType>(trim_copy(_right->getValue(parameters, variables, object, request)))
) ? "1" : "0");
return string();
}
GameState gamestate_from_goal_position(const std::string& ss, int* num_goal)
{
GameState gs;
if (!gamestate_from_input(ss, &gs)) {
throw std::runtime_error("unable to parse input string");
}
std::vector<std::string> tokens;
split(tokens, ss, "cangoal", false);
assert(tokens.size() == 2);
std::string cangoal = trim_copy(tokens[1]);
if (cangoal == "false") {
*num_goal = -1;
}
else if (cangoal == "true") {
*num_goal = 5;
}
else if (cangoal == "1") {
*num_goal = 1;
}
else if (cangoal == "2") {
*num_goal = 2;
}
else if (cangoal == "3") {
*num_goal = 3;
}
else if (cangoal == "4") {
*num_goal = 4;
}
else {
assert(0);
}
return gs;
}
bool gamestate_from_input(const std::string& ss, GameState *gs)
{
gs->clear(); // error sentinel.
std::vector<std::string> lines;
split(lines, ss, "\n", false);
for (unsigned int i=0; i < lines.size(); ++i) {
lines[i] = trim_copy(lines[i]);
}
// get color to move.
std::vector<std::string> tokens;
split(tokens, lines[0], " ", false);
to_lower(tokens[0]);
const char color = tokens[0][tokens[0].size() - 1];
if (color == 'w' || color == 'g') {
gs->set_color(W);
} else if (color == 'b' || color == 's') {
gs->set_color(B);
} else {
return false;
}
// parse game position
const int start_line = 2;
for (unsigned int line_idx=start_line; line_idx < start_line+8; ++line_idx) {
tokens.clear();
// After splitting on '|', tokens[0] is the line number. tokens[1] is
// the board contents.
split(tokens, lines[line_idx], "|", false);
// row_idx: labels the row we're in such that row_idx == 0 is gold's
// territory; row_idx == 7 is silver's.
uint8_t row_idx = 7 - (line_idx - start_line);
int piece_color;
int this_piece;
uint8_t idx;
for (uint8_t col_idx=0; col_idx < tokens[1].size() - 1; col_idx += 2) {
const char piece_or_empty = tokens[1][col_idx+1];
if (piece_or_empty == ' ' || piece_or_empty == 'x' ||
piece_or_empty == 'X' || piece_or_empty == '.') {
continue;
}
this_piece = piece_from_char(piece_or_empty);
if (this_piece == kInvalidPiece)
return false;
piece_color = color_from_char(piece_or_empty);
idx = row_idx * 8 + col_idx / 2;
gs->add_piece_at(piece_color, this_piece, idx);
}
}
return true;
}
void TestCasesHandler::TestCaseInput::addCharacters(const StringPimpl &characters) throw(InternalProgrammerErrorException &)
{
string characterString(characters.c_str());
typedef tokenizer<char_separator<char> > tokenize;
typedef tokenizer<char_separator<char> >::const_iterator CI;
char_separator<char> sep("\n");
tokenize expectedAnswerTokens(characterString, sep);
if(expectedAnswerTokens.begin() != expectedAnswerTokens.end())
{
for(CI it = expectedAnswerTokens.begin(); it != expectedAnswerTokens.end(); ++it)
{
m_characters += " " + trim_copy(*it);
}
}
else
{
m_characters += trim_copy(characterString);
}
}
void KeysValues::ReadLine(CS& line) {
// separate with sep_kv
vector<string> kv;
split(kv, line, is_any_of(sep_kv_));
// check the structure
if(kv.size() != 2) {
string msg;
SUB_LOCATION(msg);
msg += "line must be 'key:value'";
throw runtime_error(msg);
}
// copy
string key = trim_copy(kv[0]);
string val = trim_copy(kv[1]);
// string key = kv[0];
// string val = kv[1];
// add key value as string
this->Add<string>(key, val);
}
/** Parse a card row from a keyFile
* @param std::string text : text string of the row
* @param size_t iCardRow : text string of the row.
*
* Parse a keyword line belonging to this DynaKeyword. The constructor shall
* be invoked with the keywords name itself e.g. *SECTION_SHELL. The next
* following lines may be given to this routine.
*/
void
DynaKeyword::parse_keyfile_row(std::string _line, const size_t iCardRow)
{
std::string line_trimmed = trim_copy(_line);
// values present
if (!line_trimmed.empty()) {
// save the card entries
this->rows.insert(std::pair<size_t, std::string>(iCardRow, line_trimmed));
// no values
} else {
++this->nEmptyLines;
return;
}
}
explicit UnitType(vector<string> const& xs) {
assert(xs.size() >= 15);
name = trim_copy(xs[0]);
id = stoi(xs[1]);
speed = stoi0(xs[2]);
attack = stoi0(xs[3]);
combat = stoi0(xs[4]);
slots = stoi0(xs[5]);
size = stoi0(xs[6]);
icon = stoi0(xs[7]);
travel = stoi0(xs[8]);
base = stoi0(xs[9]);
item1 = stoi0(xs[10]);
num1 = stoi0(xs[11]);
item2 = stoi0(xs[12]);
num2 = stoi0(xs[13]);
cost = stoi0(xs[14]);
icon_expert = stoi0(xs[15]);
}
void TestCasesHandler::Description::addCharacters(const StringPimpl &characters) throw(InternalProgrammerErrorException &)
{
string characterString(characters.c_str());
m_characters += trim_copy(characterString);
}
void TestCasesHandler::getResponse()
{
string response = m_builder.getResponse(m_input.c_str()).c_str();
outputln("Response: " + response);
if(!m_expectedAnswer.empty())
{
if(response == m_expectedAnswer)
{
outputln("<p style=\"color:green\">[OK]</p>");
}
else
{
outputln("<p style=\"color:red\">[FAILED]</p>");
}
}
else if(!m_keyWords.empty())
{
typedef vector<string>::const_iterator VCI;
bool allFound = true;
for(VCI it = m_keyWords.begin(); it != m_keyWords.end(); ++it)
{
typedef tokenizer<char_separator<char> > tokenize;
typedef tokenizer<char_separator<char> >::const_iterator CI;
char_separator<char> sep(",");
tokenize keyWordsToken((*it), sep);
bool oneFound = false;
for(CI it = keyWordsToken.begin(); it != keyWordsToken.end(); ++it)
{
string toLookFor = trim_copy(*it);
if(find_first(response, toLookFor))
{
erase_first(response, toLookFor);
oneFound = true;
break;
}
}
if(oneFound == false)
{
allFound = false;
}
}
if(allFound)
{
outputln("<p style=\"color:green\">[OK]</p>");
}
else
{
outputln("<p style=\"color:red\">[FAILED]</p>");
}
}
else
{
outputln("[No expected answer or keywords given, ERROR]");
}
outputln("");
}
std::string Exif_IO_EasyExif::getLensModel() const
{
return trim_copy( (*pimpl_).get().LensInfo.Model );
}
std::string Exif_IO_EasyExif::getBrand() const
{
return trim_copy( (*pimpl_).get().Make );
}
void readGeoGenParams(string paramFileName, Teuchos::ParameterList &geoparams, const RCP<const Teuchos::Comm<int> > & comm){
std::string input = "";
char inp[25000];
for(int i = 0; i < 25000; ++i){
inp[i] = 0;
}
bool fail = false;
if(comm->getRank() == 0){
fstream inParam(paramFileName.c_str());
if (inParam.fail())
{
fail = true;
}
if(!fail)
{
std::string tmp = "";
getline (inParam,tmp);
while (!inParam.eof()){
if(tmp != ""){
tmp = trim_copy(tmp);
if(tmp != ""){
input += tmp + "\n";
}
}
getline (inParam,tmp);
}
inParam.close();
for (size_t i = 0; i < input.size(); ++i){
inp[i] = input[i];
}
}
}
int size = input.size();
if(fail){
size = -1;
}
comm->broadcast(0, sizeof(int), (char*) &size);
if(size == -1){
throw "File " + paramFileName + " cannot be opened.";
}
comm->broadcast(0, size, inp);
istringstream inParam(inp);
string str;
getline (inParam,str);
while (!inParam.eof()){
if(str[0] != param_comment){
size_t pos = str.find('=');
if(pos == string::npos){
throw "Invalid Line:" + str + " in parameter file";
}
string paramname = trim_copy(str.substr(0,pos));
string paramvalue = trim_copy(str.substr(pos + 1));
geoparams.set(paramname, paramvalue);
}
getline (inParam,str);
}
}
INT32 _sqlBsonBuilder::buildOrder( const SQL_CONTAINER &c,
BSONObj &obj )
{
INT32 rc = SDB_OK ;
BSONObjBuilder builder ;
if ( c.empty() )
{
rc = SDB_INVALIDARG ;
goto error ;
}
if ( c.begin()->children.empty() )
{
builder.append( boost::trim_copy(
string( c.begin()->value.begin(),
c.begin()->value.end()))
, 1 ) ;
}
{
SQL_CON_ITR end = c.begin()->children.end() ;
SQL_CON_ITR itr = c.begin()->children.begin();
while ( TRUE )
{
if ( itr == end )
{
break ;
}
if ( itr == end - 1 )
{
builder.append( boost::trim_copy(
string( itr->value.begin(), itr->value.end()))
, 1 ) ;
break ;
}
else
{
if ( SQL_SYMBOL_DESC == boost::to_lower_copy(boost::trim_copy(
string( (itr+1)->value.begin(),
(itr+1)->value.end() ))))
{
builder.append( boost::to_lower_copy(trim_copy(
string( itr->value.begin(), itr->value.end()))),
-1 );
itr += 2 ;
}
else if ( SQL_SYMBOL_ASC == boost::trim_copy(
string( (itr+1)->value.begin(),
(itr+1)->value.end() )))
{
builder.append( boost::trim_copy(
string( itr->value.begin(), itr->value.end())),
1 );
itr += 2 ;
}
else
{
builder.append( boost::trim_copy(
string( itr->value.begin(), itr->value.end())),
1 );
itr++ ;
}
}
}
obj = builder.obj() ;
}
done:
return rc ;
error:
goto done ;
}
AlnusNewickParser::Operator
AlnusNewickParser::scan()
{
INIT:
reset();
if (mCharacter == ' ') {
ignore();
}
if (mOperator == Operator::COLON) {
read();
goto LEADING_DIGIT;
}
// if (mOperator == Operator::QUOTATION_MARK) {
// read();
// goto ALPHABET;
// }
if (mCharacter == '\'') {
goto ALPHABET_WITH_QUOTATION_MARK;
}
if (isLabel(mCharacter)) {
read();
goto ALPHABET;
}
// if (isnumber(mCharacter)) {
// read();
// goto LEADING_DIGIT;
// }
START:
switch (mCharacter) {
// Requirements: Blanks or tabs may appear anywhere except within unquoted labels or
// branch_lengths.
case ' ':
case '\t':
case '\r':
case '\n':
ignore();
goto START;
break;
case ',':
read();
return Operator::COMMA;
case '(':
read();
return Operator::LEFT_PARENTHESIS;
case ')':
read();
return Operator::RIGHT_PARENTHESIS;
case '[':
while (mCharacter != ']') {
read();
}
goto START;
case ']':
// reset();
read();
goto INIT;
case ':':
mCharacter = ' ';
return Operator::COLON;
case ';':
mCharacter = ' ';
return Operator::SEMICOLON;
// case '\n':
// mCharacter = ' ';
// return Operator::END;
default:
// Exception?
assert(0);
break;
}
LEADING_DIGIT:
if (mCharacter == '-' || mCharacter == '+') {
read();
}
if (isnumber(mCharacter)) {
read();
goto LEADING_DIGIT;
} else if (mCharacter == '.') {
read();
goto TRAILING_DIGIT;
} else {
return Operator::NUMBER;
}
TRAILING_DIGIT:
if (isnumber(mCharacter)) {
read();
goto TRAILING_DIGIT;
} else {
return Operator::NUMBER;
}
ALPHABET:
while (isLabel(mCharacter)) {
// Requirements: Underscore characters in unquoted labels are converted to blanks.
if (mCharacter == '_') {
mCharacter = ' ';
}
read();
}
return Operator::LABEL;
ALPHABET_WITH_QUOTATION_MARK:
checkForQuotedLabel();
while (mCharacter != 0) {
readForQuotedLabel();
}
// Trim the string.
mBuffer = trim_copy(mBuffer);
return Operator::LABEL;
}
