std::string CEqParserV2::_getFcnSubstr(std::string &equation, int &it) { //-//-//-//-//-//-//-//-//-//-//-// // Example: 2+func((2+1),3)+42 // ^ ^ //-//-//-//-//-//-//-//-//-//-//-// bool doExit = false; bool initOk = false; int parCount = 0; std::string rVal = ""; while ((unsigned)it < equation.length() && !doExit) { char chr = equation.at(it); it++; int parCountDelta = cc::parseParanthesis(chr); parCount += parCountDelta; if (parCountDelta==1) { parCount++; initOk = true; } rVal.push_back(chr); if (initOk && parCount == 0) { return rVal; } } return ""; }
void WorldSession::LoadSecurity(std::string securitystring) { std::list<char> tmp; bool hasa = false; for(uint32 i = 0; i < securitystring.length(); ++i) { char c = securitystring.at(i); c = tolower(c); if(c == '4' || c == '3') c = 'a'; // for the lazy people if(c == 'a') { // all permissions tmp.push_back('a'); hasa = true; } else if(!hasa && (c == '0') && i == 0) break; else if(!hasa || (hasa && (c == 'z'))) { tmp.push_back(c); } } permissions = new char[tmp.size()+1]; memset(permissions, 0, tmp.size()+1); permissioncount = (uint32)tmp.size(); int k = 0; for(std::list<char>::iterator itr = tmp.begin(); itr != tmp.end(); ++itr) permissions[k++] = (*itr); if(permissions[tmp.size()] != 0) permissions[tmp.size()] = 0; sLog.outDebug("Loaded permissions for %u. (%u) : [%s]", this->GetAccountId(), permissioncount, securitystring.c_str()); }
/*! * @if jp * @brief 文字列の分割 * @else * @brief Split of string * @endif */ unsigned int CorbaNaming::split(const std::string& input, const std::string& delimiter, std::vector<std::string>& results) { typedef std::string::size_type size; size delim_size = delimiter.size(); size found_pos(0), begin_pos(0), pre_pos(0), substr_size(0); if (input.substr(0, delim_size) == delimiter) begin_pos = pre_pos = delim_size; while (1) { REFIND: found_pos = input.find(delimiter, begin_pos); if (found_pos == std::string::npos) { results.push_back(input.substr(pre_pos)); break; } if ('\\' == input.at(found_pos - 1)) { begin_pos = found_pos + delim_size; goto REFIND; } substr_size = found_pos - pre_pos; if (substr_size > 0) { results.push_back(input.substr(pre_pos, substr_size)); } begin_pos = found_pos + delim_size; pre_pos = found_pos + delim_size; } return results.size(); }
void c_rpc_server::c_session::send_response(nlohmann::json json_response) { try { const std::string response = json_response.dump(); assert(response.size() <= std::numeric_limits<uint16_t>::max()); uint16_t size = static_cast<uint16_t>(response.size()); m_write_data.resize(size + 2); ///< 2 first bytes for size m_write_data.at(0) = static_cast<char>(size >> 8); m_write_data.at(1) = static_cast<char>(size & 0xFF); for (size_t i = 0; i < response.size(); ++i) m_write_data.at(i + 2) = response.at(i); // send response dbg("send packet"); dbg(m_write_data); std::array<unsigned char, crypto_auth_hmacsha512_BYTES> hash; int ret = crypto_auth_hmacsha512(hash.data(), reinterpret_cast<unsigned char *>(&m_write_data.at(2)), size, m_rpc_server_ptr->m_hmac_key.data()); if (ret != 0) _throw_error(std::runtime_error("crypto_auth_hmacsha512 error")); dbg("hmac"); //for (const auto & byte : hash) std::cout << std::hex << "0x" << static_cast<int>(byte) << " "; //std::cout << std::dec << std::endl; std::array<boost::asio::const_buffer, 2> buffers = { {boost::asio::buffer(m_write_data.data(), m_write_data.size()), boost::asio::buffer(hash.data(), hash.size())} }; m_socket.async_write_some(buffers, [this](const boost::system::error_code& error, std::size_t bytes_transferred) { write_handler(error, bytes_transferred); }); } catch (const std::exception &e) { _erro( "exception in execute_rpc_command " << e.what() ); _erro( "close connection\n" ); delete_me(); return; } }
std::string Util::nameToDescription(const std::string& name) { std::stringstream ss; bool prevWasUpper = false; bool nextToUpper = false; for (int i = 0; i < name.length(); i++) { char c = name.at(i); if (isupper(c)) { if (!prevWasUpper && i != 0) { ss <<" "; } prevWasUpper = true; }else { prevWasUpper = false; } if (i == 0 || nextToUpper) { c = toupper(c); nextToUpper = false; } if (c == '_') { ss <<" "; nextToUpper = true; }else{ ss <<c; } } return ss.str(); }
std::string RemoveComments(const std::string Str) { std::string Result; int k = 0; int AwatingEOL = 0; ptrdiff_t len = Str.length() - 1; for (ptrdiff_t i = 0; i < len; i++) { if (AwatingEOL) { if (Str[i] != '\n') continue; else { AwatingEOL = 0; continue; } } else { if (Str[i] == '/' && Str[i + 1] == '/') { AwatingEOL = true; continue; } else { Result.push_back(Str.at(i)); k++; } } } Utility::ReplaceAll(Result, "[\\n\\r ]", ""); return Result; }
bool stage_t::set_dir( std::string const & dir) { if ( dir_exists(dir)){ if ( (m_temp_dir_name != "") && (m_remove_dir_on_exit == true) && (m_temp_dir_name != dir)){ std::string cmd = "rmdir " + m_temp_dir_name; // std::cout <<" cmd is " << cmd << '\n'; int result = system (cmd.c_str()); if (result == -1){ std::cout << "warning couldnt remove old temp dir\n"; } } m_remove_dir_on_exit = false; if ( dir.at(dir.length() -1) != get_platform()->get_dir_sep().at(0)){ m_temp_dir_name = dir + get_platform()->get_dir_sep(); }else{ m_temp_dir_name = dir; } return true; }else{ std::cout << "dir not found\n"; return false; } }
bool Database::filterIsValid(std::string filter) { /* Clean the filter term of any caps*/ std::string cleaned = ""; for (unsigned int i = 0; i < filter.length(); ++i) { cleaned.push_back(tolower(filter.at(i))); } if (cleaned.compare("age") == 0) return true; else if (cleaned.compare("ssn") == 0) return true; else if (cleaned.compare("email") == 0) return true; else if (cleaned.compare("phone") == 0) return true; else if (cleaned.compare("job") == 0) return true; if (filter.compare("age") == 0) return true; else if (filter.compare("ssn") == 0) return true; else if (filter.compare("email") == 0) return true; else if (filter.compare("phone") == 0) return true; else if (filter.compare("job") == 0) return true; std::cout << "Error: Invalid filter" << std::endl; return false; }
void dump() { const std::string grayscale = " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$"; std::cerr << "\n"; double max = 0.0; for(double f: frequencies) { max = std::max(f, max); } const double scale = (grayscale.size() - 1) / max; static bool printed = false; if(printed) { std::cerr << "\033[19A"; } std::cerr << "+--------------------------------------------------+\n"; for(uint h = 0 ; h < 256; h += 16) { std::cerr << "|"; for(uint l = 0 ; l < 16; l += 1) { std::cerr << " " << grayscale.at(scale * frequencies[h + l]); } std::cerr << " |\n"; } std::cerr << "+--------------------------------------------------+\n"; printed = true; }
std::vector< std::string > list_devices( std::string p, unsigned char t, bool rec ) { std::vector< std::string > v_dev; DIR *dir; struct dirent *dir_ent; // optionally correction of path param if( p.at( p.length()-1 ) != '/' ) { p += '/'; } if( (dir = opendir( p.c_str() )) ) { while( (dir_ent = readdir( dir )) ) { if( (strcmp( dir_ent->d_name, "." ) == 0) || (strcmp( dir_ent->d_name, ".." ) == 0) ) { continue; /* ignore + jump to next */ } else { std::string tmp_str = p; tmp_str += dir_ent->d_name; if( dir_ent->d_type == t ) { v_dev.push_back( std::string( tmp_str ) ); } if( (dir_ent->d_type == DT_DIR) && rec ) { std::vector< std::string > tmp_v; v_dev.push_back( std::string( tmp_str ) ); tmp_v = list_devices( tmp_str, t, rec ); v_dev.insert( v_dev.end(), tmp_v.begin(), tmp_v.end() ); } else { continue; /* ignore + jump to next */ } } // end pathcheck if } // end while loop closedir( dir ); } else { /* nothing to do */ } return v_dev; }
vector<size_t> MicroCompiler::_ParseArgumentIndices(const std::string &action) { vector<size_t> indices; bool isIndex(false); for(size_t i = 0; i < action.size(); i++) { if (action.at(i) == '$') { if (isIndex) { indices.push_back(_LeftIndex); isIndex = false; } else isIndex = true; continue; } else if(isIndex) { const size_t comma = action.find_first_of(',', i); const size_t rParen = action.find_first_of(')', i); const size_t numBytes = (comma < rParen ? comma : rParen) - i; const string num(action.substr(i, numBytes)); indices.push_back(_RightIndex + boost::lexical_cast<size_t>(num) -1); isIndex = false; } } if (Debug) { cout << "Indices for : " << action << " is "; std::copy(indices.begin(), indices.end(), std::ostream_iterator<size_t>(std::cout, ",")); cout << endl; } return indices; }
protein::protein(std::string p, double temp) { seq = p; pH = temp; std::cout << "Calculating net charge for " << p.length() << " membered protein\n\n"; //Allocate memory to chop string residue = new char[p.length()]; size = p.length(); for (unsigned count = 0; count < p.length(); count++) { //Chop string into char residue[count] = p.at(count); } protein::storeCharge(pH); //Find total charge using net charge at R group. for (unsigned count = 0; count < size; count++) { totalCharge += ratio[protein::getNumber(residue[count])][2]; } //Add to the total charge the net charge at COOH and NH3. totalCharge += ratio[protein::getNumber(residue[0])][1]; totalCharge += ratio[protein::getNumber(residue[size - 1])][0]; std::cout << "\nNet Charge of Peptide : " << totalCharge << std::endl; }
std::vector<std::string> generateAllCombinations(std::string s) { std::vector<std::string> v; std::vector<std::string> combinations; if (s.size() == 0) { return v; } if (s.size() == 1) { v.push_back(s); return v; } char characterToMix = s.at(0); s = s.substr(1, s.size() - 1); combinations = generateAllCombinations(s); for (size_t i = 0; i < combinations.size(); ++i) { std::string combination = combinations[i]; for (size_t j = 0; j <= combination.size(); ++j) { std::string left = combination.substr(0, j); std::string right = combination.substr(j, combination.size() - j); v.push_back(left + characterToMix + right); } } return v; }
void Dialog::setText(std::string str) { unsigned int maxSize(40); unsigned int maxLine(3); if(str.length() >= maxSize) { for(unsigned int j = 1 ; j <= (unsigned int)(str.length()/maxSize); j++) { str.insert(j * maxSize , "\n"); } } unsigned int nb = 0; for(unsigned int j = 0 ; j < str.length(); j++) { if(str.at(j) == '\n') { nb++; if(nb == maxLine) { texts.push_back(str.substr(0, j + 1)); str.erase(0, j + 1); nb = 0; j = 0; } } } if(str.length() > 0 ) { texts.push_back(str); } }
std::string token_word(const std::string& in) { int pos = -1; int digits_prefixed = 0; int nalpha = 0; int len = in.size(); std::vector<char> cv; int last_quirk = -1; while (++pos < len) { char ch = in.at(pos); if (std::isdigit(ch)) { if (digits_prefixed > 0) { last_quirk = pos; break; } digits_prefixed--; cv.push_back(std::tolower(ch)); } else if (std::isalpha(ch)) { if (digits_prefixed < 0) digits_prefixed = -digits_prefixed; cv.push_back(std::tolower(ch)); nalpha++; } else { if (digits_prefixed < 0) digits_prefixed = -digits_prefixed; last_quirk = pos; if ((ch == '-' || ch == '\'') && pos != 0) { cv.push_back(ch); } else { break; } } } if (last_quirk == pos || (digits_prefixed > 0 && nalpha == 0)) cv.clear(); // invalid word return std::string(cv.begin(),cv.end()); }
bool ParseLine( const std::string &line ) { int num = 0; float fl = 0; u32 size = 0; //sikp empty lines or ones starting with # if( !line.size() || line.at( 0 ) == '#' ) return true; if( !line.compare( 0, 11, "viewportX: " ) ) { sscanf( line.c_str(), "viewportX: %i%n", &num, &size); if( size == line.size() ) { Settings::viewportX = num; return true; } } if( !line.compare( 0, 11, "viewportY: " ) ) { sscanf( line.c_str(), "viewportY: %i%n", &num, &size); if( size == line.size() ) { Settings::viewportY = num; return true; } } if( !line.compare( 0, 12, "installDir: " ) ) { installDir = line.substr( 12 ); return true; } cout << "failed to parse setting line: \"" << line << "\"" << endl; return false; }
/** * Append a single token to the given list of tokens. * The token is assumed to be lowercase, free of comments, and non-blank. * This function is for handling shortcut * syntax, e.g. 1 4r, which should translate into four copies of the token 1 */ void appendToTokenList( const std::string& token, token_list_t& tokens ){ if( token.find_first_of("123456789") == 0 && token.at(token.length()-1) == 'r' ){ // token starts with a number and ends with r: treat as repeat syntax. const char* string = token.c_str(); char* p; int num = strtol( string, &p, 10 ); if( (p - string) != static_cast<int>(token.length()) - 1 ){ // oops, this isn't repeat format after all tokens.push_back(token); return; } if( OPT_DEBUG ) { std::cout << "Repeat syntax: " << token << " repeats " << tokens.back() << " " << num << " times." << std::endl; } for( int i = 0; i < num; ++i){ const std::string& last_tok = tokens.back(); tokens.push_back( last_tok ); } } else{ tokens.push_back(token); } }
std::string util::parseThreadId(std::string op) { //for branch operations, we parse the thread id after the first "-" if(op.find("branch")!=string::npos){ int posBegin = (int)op.find_first_of("-")+1; int posEnd = (int)op.find_first_of("-", posBegin); string tid = op.substr(posBegin, posEnd-posBegin); return op.substr(posBegin, posEnd-posBegin); } //for branch operations, we parse the thread id after the second "-" int posBegin = (int)op.find_first_of("-", op.find_first_of("-") + 1)+1; while(op.at(posBegin) == '>') posBegin = (int)op.find_first_of("-", posBegin) + 1; //for read operations, we have to consider the readId as well int posEnd = (int)op.find_first_of("-", posBegin); int posEnd2 = (int)op.find_first_of("&", posBegin); if(posEnd != string::npos) return op.substr(posBegin, posEnd-posBegin); return op.substr(posBegin, posEnd2-posBegin); }
/** * add a step to the history variable */ std::string CHistory::addToHistory(char steptype, std::string const &prevhist) { std::string history; size_t histLenMinus1 = prevhist.length(); char last; if(histLenMinus1>0) { histLenMinus1--; last = prevhist.at(histLenMinus1); } else { last = '\0'; } if( last == EvaporationResidue && steptype == Evaporation ) history = prevhist.substr(0,histLenMinus1) + Evaporation; else if( last == EvaporationResidue && steptype == EvaporationResidue ) history = prevhist; else if( last == SaddleToScission && steptype == SaddleToScission ) history = prevhist; else history = prevhist + steptype; return history; }
T lexical_cast_integer(const std::string &str) { bool containsHexValues = false; bool containsNegative = false; for (int i = 0; i < str.size(); ++i) { char c = str.at(i); if ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) { containsHexValues = true; } else if (!(c >= '0' && c <= '9') && c != 'x' && c != '-') { throw std::runtime_error("Invalid cast"); } } int start = 0; bool isHex = containsHexValues; if (str.size() > 1 && str.at(start) == '-') { ++start; containsNegative = true; } if (str.size() > (start + 1) && str.at(start) == 'x') { start ++; isHex = true; } if (str.size() > (start + 2) && str.at(start) == '0' && str.at(start + 1) == 'x') { isHex = true; start += 2; } T value = 0; T base = (isHex ? 16 : 10); for (; start < str.size(); ++start) { char c = str.at(start); T place = ( (c >= '0' && c <= '9') ? (T)(c - '0') : ( (c >= 'A' && c <= 'F') ? ((T)(c - 'A') + 10) : (c >= 'a' && c <= 'f') ? ((T)(c - 'a') + 10) : 0)); value = value * base + place; } if (containsNegative) { value = -value; } return value; }
inline bool Util_Parser::levelValido(std::string &name) { try { if (name.size() > 99 ) { NotifyWarning("levelValido: valor de level demasiado largo", "Util_Parser.cpp"); return false; } char c1[100]; for(unsigned i = 0; i<name.size(); i++) { name.at(i) = toupper(name.at(i)); c1[i] = name.at(i); } char c2[] = "DEBUG"; char c3[] = "INFO"; char c4[] = "ERROR"; NotifyMessage("levelValido: obteniendo level ", "Util_Parser.cpp"); if((strncasecmp(c1,c2,2))==0) { name = "debug"; NotifyMessage("levelValido: level seteado:" + name, "Util_Parser.cpp");; return true; } if((strncasecmp(c1,c3,2))==0) { name = "info"; NotifyMessage("levelValido: level seteado:" + name, "Util_Parser.cpp"); return true; } if((strncasecmp(c1,c4,2))==0) { name = "error"; NotifyMessage("levelValido: level seteado:" + name, "Util_Parser.cpp"); return true; } name = ""; NotifyWarning("levelValido: valor de level invalido", "Util_Parser.cpp"); return false; } catch(const std::runtime_error& re) { NotifyError("Error en Runtime: ", "Util_Parser.cpp"); NotifyError(re.what(), "Util_Parser.cpp"); return false; } catch(const std::exception& ex) { NotifyError("Ha ocurrido un error: ", "Util_Parser.cpp"); NotifyError(ex.what(), "Util_Parser.cpp"); return false; } catch(...) { NotifyError("Error desconocido que no se ha podido especificar.", "Util_Parser.cpp"); return false; } }
//pasar por referencia inline bool Util_Parser::formacionValido(std::string &name) { try { if (name.size() > 99 ) { NotifyWarning("formacionValido: valor de formacion demasiado largo", "Util_Parser.cpp"); return false; } char c1[100]; for(unsigned i = 0; i<name.size(); i++) { c1[i] = name.at(i); } char c2[] = "3-3"; char c3[] = "3-1-2"; char c4[] = "3-2-1"; NotifyMessage("formacionValido: obteniendo formacion ", "Util_Parser.cpp"); if((strncasecmp(c1,c2,3))==0) { name = "3-3"; NotifyMessage("formacionValido: formacion seteado:" + name, "Util_Parser.cpp"); return true; } if((strncasecmp(c1,c3,3))==0) { name = "3-1"; NotifyMessage("formacionValido: formacion seteado:" + name, "Util_Parser.cpp"); return true; } if((strncasecmp(c1,c4,3))==0) { name = "3-2-1"; NotifyMessage("casacaValido: formacion seteado:" + name, "Util_Parser.cpp"); return true; } name = ""; NotifyWarning("formacionValido: valor de formacion invalido", "Util_Parser.cpp"); return false; } catch(const std::runtime_error& re) { NotifyError("Error en Runtime: ", "Util_Parser.cpp"); NotifyError(re.what(), "Util_Parser.cpp"); return false; } catch(const std::exception& ex) { NotifyError("Ha ocurrido un error: ", "Util_Parser.cpp"); NotifyError(ex.what(), "Util_Parser.cpp"); return false; } catch(...) { NotifyError("Error desconocido que no se ha podido especificar.", "Util_Parser.cpp"); return false; } }
//pasar por referencia inline bool Util_Parser::casacaValido(std::string &name) { try { if (name.size() > 99 ) { NotifyWarning("casacaValido: valor de casaca demasiado largo", "Util_Parser.cpp"); return false; } char c1[100]; for(unsigned i = 0; i<name.size(); i++) { name.at(i) = toupper(name.at(i)); c1[i] = name.at(i); } char c2[] = "PRINCIPAL"; char c3[] = "SUPLENTE"; char c4[] = "AUXILIAR"; NotifyMessage("casacaValido: obteniendo casaca ", "Util_Parser.cpp"); if((strncasecmp(c1,c2,2))==0) { name = "principal"; NotifyMessage("casacaValido: casaca seteado:" + name, "Util_Parser.cpp"); return true; } if((strncasecmp(c1,c3,2))==0) { name = "suplente"; NotifyMessage("casacaValido: casaca seteado:" + name, "Util_Parser.cpp"); return true; } if((strncasecmp(c1,c4,2))==0) { name = "auxiliar"; NotifyWarning("casaca Auxiliar: casaca seteado:" + name, "Util_Parser.cpp"); return true; } name = ""; NotifyWarning("casacaValido: valor de casaca invalido", "Util_Parser.cpp"); return false; } catch(const std::runtime_error& re) { NotifyError("Error en Runtime: ", "Util_Parser.cpp"); NotifyError(re.what(), "Util_Parser.cpp"); return false; } catch(const std::exception& ex) { NotifyError("Ha ocurrido un error: ", "Util_Parser.cpp"); NotifyError(ex.what(), "Util_Parser.cpp"); return false; } catch(...) { NotifyError("Error desconocido que no se ha podido especificar.", "Util_Parser.cpp"); return false; } }
ShipType::ShipType(const Id &_id, const std::string &path) { Json::Reader reader; Json::Value data; isGlobalColorDefined = false; auto fd = FileSystem::gameDataFiles.ReadFile(path); if (!fd) { Output("couldn't open ship def '%s'\n", path.c_str()); return; } if (!reader.parse(fd->GetData(), fd->GetData()+fd->GetSize(), data)) { Output("couldn't read ship def '%s': %s\n", path.c_str(), reader.getFormattedErrorMessages().c_str()); return; } // determine what kind (tag) of ship this is. const std::string tagStr = data.get("tag", "").asString(); if( tagStr.empty() || strcasecmp(tagStr.c_str(), "ship")==0 ) { tag = TAG_SHIP; } else if( strcasecmp(tagStr.c_str(), "static")==0 ) { tag = TAG_STATIC_SHIP; } else if( strcasecmp(tagStr.c_str(), "missile")==0 ) { tag = TAG_MISSILE; } id = _id; name = data.get("name", "").asString(); shipClass = data.get("ship_class", "").asString(); manufacturer = data.get("manufacturer", "").asString(); modelName = data.get("model", "").asString(); cockpitName = data.get("cockpit", "").asString(); linThrust[THRUSTER_REVERSE] = data.get("reverse_thrust", 0.0f).asFloat(); linThrust[THRUSTER_FORWARD] = data.get("forward_thrust", 0.0f).asFloat(); linThrust[THRUSTER_UP] = data.get("up_thrust", 0.0f).asFloat(); linThrust[THRUSTER_DOWN] = data.get("down_thrust", 0.0f).asFloat(); linThrust[THRUSTER_LEFT] = data.get("left_thrust", 0.0f).asFloat(); linThrust[THRUSTER_RIGHT] = data.get("right_thrust", 0.0f).asFloat(); angThrust = data.get("angular_thrust", 0.0f).asFloat(); // Parse global thrusters color bool error = false; int parse = 0; for( Json::Value::iterator thruster_color = data["thruster_global_color"].begin() ; thruster_color != data["thruster_global_color"].end() ; ++thruster_color ) { const std::string colorchannel = thruster_color.key().asString(); if (colorchannel.length()!=1) { error = true; break; } if (colorchannel.at(0) == 'r') { globalThrusterColor.r = data["thruster_global_color"].get(colorchannel, 0).asInt(); parse++; continue; } else if (colorchannel.at(0) == 'g') { globalThrusterColor.g = data["thruster_global_color"].get(colorchannel, 0).asInt(); parse++; continue; } else if (colorchannel.at(0) == 'b') { globalThrusterColor.b = data["thruster_global_color"].get(colorchannel, 0).asInt(); parse++; continue; } else { // No 'r', no 'g', no 'b', no good :/ error = true; break; } } if (error==true) { Output("In file \"%s.json\" global thrusters custom color must be \"r\",\"g\" and \"b\"\n", modelName.c_str()); } else if (parse>0 && parse<3) { Output("In file \"%s.json\" global thrusters custom color is malformed\n", modelName.c_str()); } else if (parse==3) { globalThrusterColor.a = 255; isGlobalColorDefined = true; } // Parse direction thrusters color for (int i=0; i<THRUSTER_MAX; i++) isDirectionColorDefined[i]=false; error = false; for( Json::Value::iterator thruster_color = data["thruster_direction_color"].begin() ; thruster_color != data["thruster_direction_color"].end() ; ++thruster_color ) { const std::string th_color_dir = thruster_color.key().asString(); Json::Value dir_color = data["thruster_direction_color"].get(th_color_dir, 0); Color color; if (!dir_color.isMember("r")||!dir_color.isMember("g")||!dir_color.isMember("b")) { error = true; continue /* for */; } else { color.r = dir_color["r"].asInt(); color.g = dir_color["g"].asInt(); color.b = dir_color["b"].asInt(); color.a = 255; } if (th_color_dir.find("forward")!=std::string::npos) { isDirectionColorDefined[THRUSTER_FORWARD]=true; directionThrusterColor[THRUSTER_FORWARD]= color; } if (th_color_dir.find("retro")!=std::string::npos) { isDirectionColorDefined[THRUSTER_REVERSE]=true; directionThrusterColor[THRUSTER_REVERSE]= color; } if (th_color_dir.find("left")!=std::string::npos) { isDirectionColorDefined[THRUSTER_LEFT]=true; directionThrusterColor[THRUSTER_LEFT]= color; } if (th_color_dir.find("right")!=std::string::npos) { isDirectionColorDefined[THRUSTER_RIGHT]=true; directionThrusterColor[THRUSTER_RIGHT]= color; } if (th_color_dir.find("up")!=std::string::npos) { isDirectionColorDefined[THRUSTER_UP]=true; directionThrusterColor[THRUSTER_UP]= color; } if (th_color_dir.find("down")!=std::string::npos) { isDirectionColorDefined[THRUSTER_DOWN]=true; directionThrusterColor[THRUSTER_DOWN]= color; } } if (error==true) { for (int i=0; i<THRUSTER_MAX; i++) isDirectionColorDefined[i]=false; Output("In file \"%s.json\" directional thrusters custom color must be \"r\",\"g\" and \"b\"\n", modelName.c_str()); } // invert values where necessary linThrust[THRUSTER_FORWARD] *= -1.f; linThrust[THRUSTER_LEFT] *= -1.f; linThrust[THRUSTER_DOWN] *= -1.f; // angthrust fudge (XXX: why?) angThrust = angThrust * 0.5f; hullMass = data.get("hull_mass", 100).asInt(); capacity = data.get("capacity", 0).asInt(); fuelTankMass = data.get("fuel_tank_mass", 5).asInt(); for( Json::Value::iterator slot = data["slots"].begin() ; slot != data["slots"].end() ; ++slot ) { const std::string slotname = slot.key().asString(); slots[slotname] = data["slots"].get(slotname, 0).asInt(); } for( Json::Value::iterator role = data["roles"].begin(); role != data["roles"].end(); ++role ) { const std::string rolename = role.key().asString(); roles[rolename] = data["roles"].get(rolename, 0).asBool(); } for(int it=0;it<4;it++) thrusterUpgrades[it] = 1.0 + (double(it)/10.0); for( Json::Value::iterator slot = data["thrust_upgrades"].begin() ; slot != data["thrust_upgrades"].end() ; ++slot ) { const std::string slotname = slot.key().asString(); const int index = Clamp(atoi(&slotname.c_str()[9]), 1, 3); thrusterUpgrades[index] = data["thrust_upgrades"].get(slotname, 0).asDouble(); } atmosphericPressureLimit = data.get("atmospheric_pressure_limit", 10.0).asDouble(); // 10 atmosphere is about 90 metres underwater (on Earth) { const auto it = slots.find("engine"); if (it != slots.end()) { it->second = Clamp(it->second, 0, 1); } } effectiveExhaustVelocity = data.get("effective_exhaust_velocity", -1.0f).asFloat(); const float thruster_fuel_use = data.get("thruster_fuel_use", -1.0f).asFloat(); if(effectiveExhaustVelocity < 0 && thruster_fuel_use < 0) { // default value of v_c is used effectiveExhaustVelocity = 55000000; } else if(effectiveExhaustVelocity < 0 && thruster_fuel_use >= 0) { // v_c undefined and thruster fuel use defined -- use it! effectiveExhaustVelocity = GetEffectiveExhaustVelocity(fuelTankMass, thruster_fuel_use, linThrust[Thruster::THRUSTER_FORWARD]); } else { if(thruster_fuel_use >= 0) { Output("Warning: Both thruster_fuel_use and effective_exhaust_velocity defined for %s, using effective_exhaust_velocity.\n", modelName.c_str()); } } baseprice = data.get("price", 0.0).asDouble(); minCrew = data.get("min_crew", 1).asInt(); maxCrew = data.get("max_crew", 1).asInt(); hyperdriveClass = data.get("hyperdrive_class", 1).asInt(); }
bool menu::item_ends_with_image(const std::string& item) const { std::string::size_type pos = item.find_last_of(IMG_TEXT_SEPARATOR); pos = (pos == std::string::npos) ? 0 : pos+1; return(item.size() > pos && item.at(pos) == IMAGE_PREFIX); }
//! (internal) hashvalue EScript::_hash( const std::string & s) { hashvalue h=0; for (size_t i=0;i<s.length();++i) h^=(((s.at(i)+h)*1234393)% 0xffffff); return h; }
void tb_draw_string(int x, int y, const std::string &str, uint16_t fg, uint16_t bg) { for (std::size_t i = 0; i < str.size(); ++i) { tb_change_cell(x + i, y, str.at(i), fg, bg); } }
bool ImageLoader::insertColor(std::string &oneLine) { string temp;//temporary copy of oneLine, used to shorten it stringstream converter;//converts strings into ints char colorName = ' ';//used to refer to this color in the file unsigned int redCol = 0;//the components of this color unsigned int greenCol = 0; unsigned int blueCol = 0; bool result = true;//false if the line was malformed //cout << "ImageLoader::insertColor(): added " << oneLine << endl; //### Verify that there are at least 6 chars ### if (oneLine.size() < 6) { cout << "ImageLoader::insertColor(): line with less than 6 chars" << endl; result = false; }//if size() //### Extract the color name ### if (result) { colorName = oneLine.at(0); if (fileColors.find(colorName) != fileColors.end()) { cout << "ImageLoader::insertColor(): Color " << colorName << " is present multiple times" << endl; result = false; }//if find() }//if result //### Strip everything but space-separated color values ### if (result) { temp.clear(); temp.append(oneLine, 5, oneLine.size() - 6); oneLine.clear(); for (unsigned int i = 0; i < temp.size(); i++) { if (temp.at(i) != ',') oneLine.push_back(temp.at(i)); }//for i }//if result //### Extract the red color ### if (result) { converter << oneLine; converter >> redCol; if (!converter.good()) { cout << "ImageLoader::insertColor(): invalid red color given" << endl; result = false; }//if !good() }//if result //### Extract the green color ### if (result) { converter >> greenCol; if (!converter.good()) { cout << "ImageLoader::insertColor(): invalid green color given" << endl; result = false; }//if !good() }//if result //### Extract the blue color ### if (result) { converter >> blueCol; if (converter.fail()) { cout << "ImageLoader::insertColor(): invalid blue color given" << endl; result = false; }//if fail() }//if result //### Insert the colors into the map ### if (result) fileColors.insert(pair<char, QRgb>(colorName, qRgb(redCol, greenCol, blueCol))); return result; }//insertColor
//int doffire(unsigned tmax=1000000, unsigned short fmatch=200, unsigned int randPlant=1, unsigned int clustPlant=0, unsigned short burnAge=1, unsigned short burnPropAge=1, int rhoRocks=0, int doSQL=1, float pImmune=0, int nnnAge=0) { int doffire(unsigned int tmax=1000000, unsigned int fmatch=125, int doSQL=2, float pImmune=0, float kImmune=1, std::string immCode=std::string("100") ) { // immCode: [1]: cluster level, [2]: fire-front elements, [3]: each new element. (evaluate immunity at these times). //printf("test immCode: %s\n", immCode.c_str()); if (immCode.at(2)==std::string("1")[0] ) printf("and we are not doing perim-level immunity.\n"); bool doImPrim=0, doImFlameFront=0, doImFireElement=0; if (immCode.at(2)==std::string("1")[0] ) doImPrim=1; if (immCode.at(1)==std::string("1")[0] ) doImFlameFront=1; if (immCode.at(0)==std::string("1")[0] ) doImFireElement=1; int aveRho = 0, aveVol=0; int burnAge=1, burnPropAge=1; int nTreesOnGrid=0; std::string simName("ForestFire5c"); std::string simPramComment("single-pass fire propagation/immunity evaluation"); // unsigned short rFire = 1; unsigned int nBurning = 1; unsigned short dnBurning = 1; int thisXY, xFire, yFire; // int thisStatus; int * thisSquare, * fireSquare; unsigned int nBurnedTotal=0, nFires=0; // number of elements burning, new Elements burning... float aveTreeAge=0; //signed int grids[(ymax+2)*(xmax+2)]; int *grids = new int[(ymax+2)*(xmax+2)]; //int *directions = new int[4]; //*directions={1,-1, xmax+2, -(xmax+2)}; int directions[4]={1,-1, xmax+2, -(xmax+2)}; //int randDirs[4]={1,-1, xmax+2, -(xmax+2)}; // new array to be randomized int *newOrder = new int[4]; // v9: int *fireList = new int[(ymax)*(xmax)]; unsigned int *fcounts = new unsigned int[(ymax)*(xmax)]; unsigned short newFireElements=0; // [x, x, x, x, x, x[nBurning], x, x, x, x[dnBurning], x, x, x, x[newFireElements] ]: old-fire, current flame-front, new elements. unsigned int totalFireCount=0; // bool doQuench = 0; // float frandImmune=0; int randImmune = 0; // //unsigned int rhoRocks = 10; // of 100 // initialize? srand(time(NULL)); // eventually, we have to be smarter about this and use independent random sets. see Gleb's random number gens. for (unsigned int i=0; i<(xmax+2)*(ymax+2); i++) { grids[i]=0; // seed the grid with some trees if (rand()%(xmax/2)==1 and i%(xmax+2)!=0 and i%(xmax+2)!=(xmax+1) and i>(xmax+2) and i<((xmax+2)*(ymax+1)) ) { grids[i]=1; nTreesOnGrid ++; }; //if (i>(xmax+2)*(ymax+1)) printf("initializing grid %d\n", i); //yodapause(); }; //printf("random grid established...\n"); //printGrid(&grids[0], 1, xmax, ymax); // char DB[]="ForestFire"; char HOST[]="localhost"; char USER[]="myoder"; char PASSWORD[]="yoda"; mysqlpp::Connection myconn(DB, HOST, USER, PASSWORD); mysqlpp::Query myquery=myconn.query(); //mysqlpp::Result res1; mysqlpp::StoreQueryResult res1; int intKey; //unsigned int fcounts[xmax*ymax]; for (unsigned int i=0; i<xmax*ymax; i++) { //fcounts[i]=0; //fireList[i]=0; *(fcounts + i)=0; *(fireList + i)=0; }; if (doSQL==1 or doSQL==5 or doSQL==25) { // // insert a new row for this sim-run: myquery.reset(); printf("insert simprams.\n"); myquery << "insert into ForestFire.SimPrams (`SimName`, `xmax`, `ymax`, `sparkInterval`, `burnAge`, `tmax`, `nRand`, `pImmune`, `kImmune`, `Comment`) values (%0q, %1q, %2q, %3q, %4q, %5q, %6q, %7q, %8q, %9q )"; myquery.parse(); // note: simIndex(auto-int) and dtTime (default TIMESTAMP) set automatically. //myquery.execute(simName.c_str(), simName.c_str(), xmax, ymax, fmatch, burnAge, tmax, randPlant, clustPlant, kmax, simPramComment.c_str()); myquery.execute(simName.c_str(), xmax, ymax, fmatch, 1, tmax, 1, pImmune, kImmune, simPramComment.c_str()); // // now, get the integer key for this simulation: // note that this could be accomplished with one call (optimal if MySQL calls have high overhead) // by writing a SPROC on the MySQL side. // also see the mysql_insert_id() (C API) and LAST_INSERT_ID() (SQL) functions, by which we should be ablt to automatically retrieve the indexID. myquery.reset(); printf("fetch simIndex.\n"); myquery << "select max(simIndex) from ForestFire.SimPrams"; myquery.parse(); res1 = myquery.store(simName.c_str(), simName.c_str()); intKey = res1.at(0).at(0); }; // doSQL // //printf("beginnn.\n"); //for (unsigned int i=0; i<=tmax; i++) { unsigned int i=0; // just so other bits don't break... while (totalFireCount<=tmax) { i++; // this might overflow i guess. if so... figure out something. //if (doSQL==5 or doSQL==6) if(i%1000000 == 0) printf("%d million\n", i/1000000); if (doSQL==6) if(i%1000000 == 0) printf("%d million\n", i/1000000); if (doSQL==16) { if(i%100000 == 0) { // printf("%d million\n", i/1000000); aveRho=0; aveVol=0; for (unsigned int k=0; k<(xmax+2)*(ymax+2); k++) { if (*(grids+k)>0 and *(grids+k)<rockAge) { aveRho = aveRho + 1; aveVol = aveVol + *(grids+k); }; }; //printf("mils,\t Rho,\t Vol,\t %d, %f, %f\n", i/1000000, float(aveRho)/float(xmax*ymax), float(aveVol)/float(xmax*ymax)); printf("%d, %f, %f\n", i/1000000, float(aveRho)/float(xmax*ymax), float(aveVol)/float(xmax*ymax)); }; }; // // PLANT A TREE: // select a grid for tree planting: //thisX = rand()%xmax+1; //thisY = rand()%ymax+1; //thisSquare = &grids[0] + thisX + (xmax+2)*thisY; // point to the current square... // for speed, select one random number; if we land on a rock, then just skip. there aren't many rocks. thisXY = xmax+3 + rand()%((xmax+2)*ymax-1); thisSquare = grids + thisXY; // if (*thisSquare<rockAge) { if (*thisSquare==0) { *thisSquare = *thisSquare + 1; nTreesOnGrid ++; }; // we've planted a tree. do we throw a match? // we can do this two ways. we can trow a match every M steps or set a // 1/M probability every time. // for now, we're being super simple; throw a match every 'fmatch' steps: // throw a match with 1/fmatch probability. generate a random number beteen 1 and fmatch; each number appears with freq. 1/fmatch //ffmatch = float(i+1)/float(fmatch); //if (float(int(ffmatch))==ffmatch and i>xmax) { //if (rand()%((1+prefPlant)*fmatch)==1) { if (rand()%fmatch==1) { //yodapause(); // throw a match. xFire = rand()%xmax+1; yFire = rand()%ymax+1; fireSquare = &grids[0] + xFire + (xmax+2)*yFire; //printf("match: (%d, %d) :: %d/%d\n", xFire, yFire, *fireSquare, *(&grids[0] + (xFire + (xmax+2)*yFire))); //yodapause(); // //printf("now evaluate *fireSquare, etc. %d\n", *fireSquare); //if (getGridStatus(*fireSquare, i) >= burnAge and getGridStatus(*fireSquare, i) < rockAge) { if (*fireSquare >= burnAge and *fireSquare < rockAge) { // initiate a new fire. // now, we have three places to test quench-immunity: // 1) after each new step of front propagation // 2) after each burning element is tested against its NN // 3) after each element is added. // when the sequence of testing is fully randomized, we can test at any level. // // use the list-method (see v9a comments at the top) to propagate the fire. //printf("set 0-grid...\n"); //*fireSquare = -(*fireSquare); // we could remove the square; we track the fire in a list (=0), but we want to be able to plot the grid... //*fireSquare=0; //printf("set fireSquare... %d, %d, %d: %d\n",xFire, yFire, xmax, (xFire + (xmax+2)*yFire)); totalFireCount++; *fireSquare=-1; fireList[0]=(xFire + (xmax+2)*yFire); // or should we use an array of addresses? //printf("set fireSquare done\n"); // rFire = 1; dnBurning = 1; nBurning = 0; newFireElements=0; // //int yFireMin = int(yodacode::greaterOf((yFire-rFire), 1)); // we always start with a 1 squar boundary. we might, however, encounter the edges. //int yFireMax = int(yodacode::lesserOf((yFire+rFire), float(ymax))); //int xFireMin = int(yodacode::greaterOf(float(xFire-rFire), 1)); //int xFireMax = int(yodacode::lesserOf(float(xFire+rFire), float(xmax))); // //printf("fire range: %d, %d, %d, %d\n", yFireMin, yFireMax, xFireMin, xFireMax); //printf("preplot\n."); // //plotGrid(&grids[0],i, xmax, ymax); if (doSQL==0) { printGrid(&grids[0], i, xmax, ymax); }; //while (dnBurning > 0) { doQuench = 0; //nFireSteps=0; // steps fire has propagated, max dist/radius from flash-point. effectively time it's been burning. //printf("fire started at %d. now propagate.\n", xFire + (xmax+2)*yFire); while (dnBurning > 0 and doQuench==0) { //dnBurning=0; // evaluate neighbors of current burn front (nBurning-1 < i < (nBurning-1)+dnBurning unsigned int fireIndex=nBurning; //unsigned int newFireIndex=0; unsigned int currentElementIndex; //printf("fire front burning. fireIndex=%d\n", fireIndex); int * randomFireSequence = new int[dnBurning]; int * testSeq = new int[dnBurning]; for (int itest=0; itest<dnBurning; itest++) { *(testSeq + itest) = itest; } scrambleList(testSeq, randomFireSequence, dnBurning); delete [] testSeq; //if (dnBurning>1) randomSequence(randomFireSequence, dnBurning); // randomize order in which we evalueate fire propagation. //for (int ilist=0; ilist<dnBurning; ilist++) { // printf("randomSequence[%d]=%d\n", ilist, randomFireSequence[ilist]); // }; // while (fireIndex < (nBurning+dnBurning) and doQuench==0) { //newFireIndex=fireIndex-nBurning; currentElementIndex=nBurning+randomFireSequence[fireIndex-nBurning]; // this is long-winded because i'm building it off the simpler non-randomized model. //printf("fire index: %d (%d, %d, %d, %d)\n", fireIndex-nBurning, fireIndex, nBurning, dnBurning, currentElementIndex); //printf("failing here? %d, %d, %d\n", nBurning, dnBurning, fireIndex-nBurning); //currentElementIndex=nBurning+randomFireSequence[fireIndex-nBurning]; // printf("nope. "); // check for fire: // to maintain symmetry, randomize directions: // randDirs //scrambleList(directions, randDirs, 4); //int ordr[4]={0,1,2,3}; //int newOrder[4]; randomSequence(newOrder,4); //scrambleList(ordr, newOrder, 4); // i think this is killing the random number generator. //printf("newOrder: %d, %d, %d, %d\n" , newOrder[0], newOrder[1],newOrder[2],newOrder[3]); for (int idir=0; idir<4; idir++) { // note: this loop format may facilitate randomization of direction later on... // nothing randomized: /* // I. if (grids[fireList[fireIndex] + directions[idir]]==1) { grids[fireList[fireIndex] + directions[idir]]=-1; fireList[nBurning + dnBurning + newFireElements]=fireList[fireIndex]+directions[idir]; newFireElements++; }; */ // order of each element (NN) randomized: /* // II. if (grids[fireList[fireIndex] + directions[newOrder[idir]]]==1) { grids[fireList[fireIndex] + directions[newOrder[idir]]]=-1; fireList[nBurning + dnBurning + newFireElements]=fireList[fireIndex]+directions[newOrder[idir]]; newFireElements++; }; */ // III. // each element (NN) and order of flame-front randomized: //printf("currentElement: %d\n", currentElementIndex); //printf("grid index: %d, %d, %d\n" , fireList[currentElementIndex], directions[newOrder[idir]], newOrder[idir]); //printf("segmentation fault test: grid-val (%d)\n", grids[fireList[currentElementIndex] + directions[newOrder[idir]]]); if (grids[fireList[currentElementIndex] + directions[newOrder[idir]]]==1) { // // add an entry to fireList. at the end of fireList [nBurning+dnBurning+newFireElements], add the fire location value, // fireList[currentElementIndex] + direction[] if (doQuench==0) { grids[fireList[currentElementIndex] + directions[newOrder[idir]]]=-1; fireList[nBurning + dnBurning + newFireElements]=fireList[currentElementIndex]+directions[newOrder[idir]]; newFireElements++; }; //if (immCode[2]=="1") { // so, do we do this before or after we evaluate the element? by doing this after we propagate the first step (so // fires are always k>1; alternatively we could use 1/(k+1)^p), we can use Pimmune>1 . if (doImFireElement) { // evaluate immunity (as each new element burns): //if (testQuench((nBurning+dnBurning+newFireElements), pImmune, kImmune)) { randImmune = rand()%RAND_MAX; frandImmune = float(randImmune)/RAND_MAX; if (frandImmune < (pImmune/pow(float(nBurning+dnBurning+newFireElements), kImmune)) ) { idir=4; doQuench=1; //printf("fire quenched during element-propagation: %d/%d\n", nBurning+dnBurning+newFireElements, fireIndex+1); //printGrid(&grids[0], i, xmax, ymax); //continue; }; }; }; // // MFI (after each element is tested to the fire). this is only allowed at this step for type III propagation (above). if we apply immunity // as each element is added and elements are added in some geometrical sequence (aka, around the fire-front), we break the symmetry and break // SOC between integer values of L^2. by itself, using the list method (in particular when we randomize direction) might fix this problem, // since it breakes down the spiral geometry of our former concentric square propagation. }; fireIndex++; // evaluate immunity (as each burning (fire-front) element propagates): //if (testQuench((nBurning+dnBurning+newFireElements), pImmune, kImmune)) { //if (immCode[1]=="1") { if (doImFlameFront) { randImmune = rand()%RAND_MAX; frandImmune = float(randImmune)/RAND_MAX; if (frandImmune < (pImmune/pow(float(nBurning+dnBurning+newFireElements), kImmune)) ) { //printf("quenched a fire at k=%d, Pq=%f/%f\n", (nBurning+dnBurning+newFireElements), pImmune/pow((nBurning+dnBurning+newFireElements), kImmune), frandImmune); doQuench=1; }; }; // // }; // this round of propagation is over (new elements have propagated to NN). nBurning = nBurning + dnBurning; dnBurning=newFireElements; newFireElements=0; delete [] randomFireSequence; // // evaluate immunity (after each full propagation step): //if (immCode[0]=="1") { if (doImPrim) { // at this point, the first step of propagation has occurred, so nominally we can use pImmune>1. // arguably, this creates a new characteristic size; maybe the omori-type immunity is a better idea? //if (testQuench((nBurning+dnBurning+newFireElements), pImmune, kImmune)) { randImmune = rand()%RAND_MAX; frandImmune = float(randImmune)/RAND_MAX; if (frandImmune < (pImmune/pow(float(nBurning+dnBurning+newFireElements), kImmune)) ) { //if (frandImmune < (pImmune/(1+float(nBurning+dnBurning+newFireElements)/kImmune) ) ){ //idir=4; doQuench=1; }; }; //printGrid(&grids[0], i, xmax, ymax); // g1.plot_xy(vfireX, vfireY, ""); }; // end fire still burining // // fire is over: nFires++; nBurnedTotal = nBurnedTotal + nBurning; nTreesOnGrid = nTreesOnGrid-nBurning; //printf("fire over; %d burned.\n", nBurning); fcounts[nBurning-1]++; // printf("fcounts[%d]: %d\n", nBurning-1, fcounts[nBurning-1]); //plotGrid(&grids[0], xmax, ymax); //printGrid(&grids[0], i, xmax, ymax); if (doSQL==0) { printGrid(&grids[0], i, xmax, ymax); }; // write fire to MySQL: if (doSQL==1) { // printf("fire size, nFires, totalBurned: (%d) (%d) (%d)\n", nBurning, nFires, nBurnedTotal); myquery.reset(); myquery << "insert into ForestFire.ForestFires (simIndex, t, xSpark, ySpark, nBurned, nTrees) values (%0q, %1q, %2q, %3q, %4q, %5q) "; myquery.parse(); myquery.execute(intKey, i, xFire, yFire, nBurning, nTreesOnGrid); //yodapause(); }; if (doSQL==3) { printf("fire at time %d\n", i); if (nBurning>=xmax/5) plotGrid (&grids[0], i, xmax, ymax, burnPropAge); }; if (doSQL==4) { if (nBurning>=xmax/5) plotGridImg (&grids[0], i, xmax, ymax, burnPropAge); }; // // fires finished burning; extinguish: unsigned int icleanup=0; while (fireList[icleanup]!=0) { //while (icleanup<nBurning+dnBurning+newFireElements){ //while (icleanup<(xmax*ymax)){ grids[fireList[icleanup]]=0; fireList[icleanup]=0; icleanup++; }; nBurning = 0; dnBurning=0; newFireElements=0; //printGrid(&grids[0], i, xmax, ymax); //fireIndex=0; }; //else printf("no tree at match point.\n"); // if match -> tree... }; // if match-time // do we initialize with 0? //printf("ary element 0,i: %d", grids[0][i]); }; // end sim-steps. // end simulation. //printf("doSQL: %d\n", doSQL); // doSQL's: // 0: 'print-grid" fires // 1: full SQL: insert each forest fire data-set into ForestFires // 2: print summary to screen. use this for direct gnuplot calls, " plot '<./ffire4...'" // 3: Print each fire to screen; "plotGrid" each fire nBurning>(25) print summary to screen at end // 4: plotGridImg each fire nBurning>(20); print summary to screen, // 5: SQL: insert just summary data to SQL; prints progress by million (will screw up plotting) // 6: report summary, progress by million. // 11: return to standard-output the last grid in full. use to make an image of the final grid. // // for super long runs (10^9 steps), it looks like the mysql connection times out, so all is lost. // renew the connection. // // if (myconn.connected()==0) myconn.connect(DB, HOST, USER, PASSWORD); mysqlpp::Connection newconn(DB, HOST, USER, PASSWORD); mysqlpp::Query newquery=myconn.query(); //mysqlpp::Result res1; //mysqlpp::Query myquery=myconn.query(); //mysqlpp::Result res1; // end-o-run summaries (print): //printf("xmax*ymax = %d; %d, %d\n", xmax*ymax, ymax, xmax); if (doSQL==2 or doSQL==25 or doSQL==3 or doSQL==4 or doSQL==6) { //printf("dosql=2 or something. we should get a summary."); for (unsigned int i=0; i<(xmax*ymax); i++) { if (fcounts[i]!=0) { printf("%d\t%d\n", i+1, fcounts[i]); //printf("%d\t%d\n", i+1, i); //printf("%d,\t%d\n", i+1, fcounts[i]); } else { //printf("finished.\nfire size, nFires, totalBurned: (%d) (%d) (%d)\n", nBurning, nFires, nBurnedTotal); }; }; }; //printf("moving past dosql2\n"); if (doSQL==5 or doSQL==25 ) { // no plots, just a summary -> SQL // for (unsigned int i=0; i<(xmax*ymax); i++) { // if (fcounts[i]!=0) printf("%d\t%d\n", i+1, fcounts[i]); // printf ("sql bits: %d, %d, %d, %d\n", intKey, tmax, i+1, fcounts[i]); newquery.reset(); newquery << "insert into ffcounts (simIndex, tmax, nBurned, nEvents) values (%0q, %1q, %2q, %3q)"; newquery.parse(); newquery.execute(intKey, tmax, i+1, fcounts[i]); //printf("%d,\t%d\n", i+1, fcounts[i]); }; }; //printf("moving past dosql5,25\n"); // return the final grid in full and give an average density at the end...? if (doSQL==11) { for (unsigned int i=0; i<(xmax+2)*(ymax+2); i++) { printf ("%d,\t%d,\t%d\n", i-int(i/(xmax+2))*(xmax+2), i/(xmax+2), getGridStatus(*(grids+i), tmax)); }; }; //g1.reset_plot(); //g1.plot_xyz(vx, vy, vGridStat, "xyz plot of TreesPlanted"); //yodacode::yodapause(); // // clean up memory? delete [] grids; delete [] fireList; delete [] fcounts; //delete [] directions; return 0; //return &grids[0]; };
//====================================================================== bool sccan_point_pair_handler:: is_string_a_sccan_run_config(std::string line){ if(verbosity){ std::cout<<"sccan_point_pair_handler -> "; std::cout<<"is_string_a_sccan_run_config() -> line: "; std::cout<<line<<std::endl; } // use DEAs for the std::string control // find enum TokenT{ digit, point, underscore, char_c, char_f, char_g, char_s, char_a, char_n, ERR }; int GetState[][23] ={ //dig point under c f g s a n { 1, -1, -1, -1, -1, -1, -1, -1, -1 }, //0 d { 2, -1, -1, -1, -1, -1, -1, -1, -1 }, //1 d { 3, -1, -1, -1, -1, -1, -1, -1, -1 }, //2 d { 4, -1, -1, -1, -1, -1, -1, -1, -1 }, //3 d { 5, -1, -1, -1, -1, -1, -1, -1, -1 }, //4 d { 6, -1, -1, -1, -1, -1, -1, -1, -1 }, //5 d { 7, -1, -1, -1, -1, -1, -1, -1, -1 }, //6 d { 8, -1, -1, -1, -1, -1, -1, -1, -1 }, //7 d { -1, -1, 9, -1, -1, -1, -1, -1, -1 }, //8 _ { 10, -1, -1, -1, -1, -1, -1, -1, -1 }, //9 d { 11, -1, -1, -1, -1, -1, -1, -1, -1 }, //10 d { 12, -1, -1, -1, -1, -1, -1, -1, -1 }, //11 d { 13, -1, -1, -1, -1, -1, -1, -1, -1 }, //12 d { -1, -1, 14, -1, -1, -1, -1, -1, -1 }, //13 _ { -1, -1, -1, -1, -1, -1, 15, -1, -1 }, //14 s { -1, -1, -1, 16, -1, -1, -1, -1, -1 }, //15 c { -1, -1, -1, 17, -1, -1, -1, -1, -1 }, //16 c { -1, -1, -1, -1, -1, -1, -1, 18, -1 }, //17 a { -1, -1, -1, -1, -1, -1, -1, -1, 19 }, //18 n { -1, -1, 20, -1, -1, -1, -1, -1, -1 }, //19 _ { 20, 21, -1, -1, -1, -1, -1, -1, -1 }, //20 d { -1, -1, -1, 22, -1, -1, -1, -1, -1 }, //21 . { -1, -1, -1, -1, 23, -1, -1, -1, -1 }, //22 c { -1, -1, -1, -1, -1, 24, -1, -1, -1 }, //23 f //24 g }; //for( int i=0; i<11;i++){std::cout<<"("<<i<<")"<<GetState[26][i]<<", ";} //std::cout<<std::endl; std::string ID; std::string tilt_x; std::string tilt_y; std::string tilt_z; std::string str_vec2D_x; std::string str_vec2D_y; int int_vec2D_count = 0; int state = 0; int char_number = 0; //std::cout<<"str laenge: "<<line.size()<<std::endl; while(state != -1 && char_number<line.size()){ TokenT token = ERR; char s = line.at( char_number); if(is_c(s)) token = char_c; if(is_f(s)) token = char_f; if(is_g(s)) token = char_g; if(is_s(s)) token = char_s; if(is_a(s)) token = char_a; if(is_n(s)) token = char_n; if(isdigit(s)) token = digit; //std::cout<<char(s)<<"==digit"<<std::endl;} if(is_point(s)) token = point; if(is_underscore(s)) token = underscore; //std::cout<<"check"<<char_number<<": "; //std::cout<<char(s)<<" state: "<<state<<" token: "<<token<<std::endl; state = (token == ERR) ? :GetState[state][token]; char_number ++; } if(state==24){return true;}else{return false;}; }