void DateSpan::merge(const std::vector<DateSpan>& in, std::vector<DateSpan>* out) { using DatePoints = std::map<const DateTime*, int, DateTimeCompare>; static const int FROM_DATE = 0x1; static const int TO_DATE = 0x2; DatePoints date; for (auto in_iter = in.begin(); in_iter != in.end(); ++in_iter) { date[&((*in_iter).from_date())] |= FROM_DATE; date[&((*in_iter).to_date())] |= TO_DATE; } auto date_next_iter = date.begin(); auto date_iter = date.begin(); for(++date_next_iter; date_next_iter != date.end(); ++date_iter, ++date_next_iter) { DateTime curr_from_date = *((*date_iter).first); DateTime curr_to_date = *((*date_next_iter).first); // 该日期不是终止日期,则去掉当前天,即日期前移1天 if (((*date_next_iter).second & TO_DATE) == 0) { curr_to_date.addDay(1); } // 确保DatePeriod:from_date < to_date if (!(curr_from_date < curr_to_date)) { continue; } char curr_period = 0; for (auto in_iter = in.begin(); in_iter != in.end(); ++in_iter) { if ((*in_iter).from_date() <= curr_from_date && curr_to_date <= (*in_iter).to_date()) { curr_period |= (*in_iter).period(); } } if (curr_period == 0) { continue; } DateSpan current(curr_from_date, curr_to_date, curr_period); bool need_pushed = true; if ((*out).size() > 0) { DateSpan& last = (*out)[(*out).size()-1]; if (canBeMerged(last, current)) { last.set_to_date(current.to_date()); last.set_period(last.period() | current.period()); need_pushed = false; } } if (need_pushed) { (*out).push_back(current); } } for (auto iter = (*out).begin(); iter != (*out).end(); ++iter) { (*iter).normalize(); } }
void do_stuff(const std::vector<int>& v, int i) { std::copy(v.begin(),v.end(), std::ostream_iterator<int>(std::cout," ")); std::cout << " i = " << i << std::endl; }
variant unit_callable::get_value(const std::string& key) const { if(key == "x") { if (loc_==map_location::null_location) { return variant(); } else { return variant(loc_.x+1); } } else if(key == "y") { if (loc_==map_location::null_location) { return variant(); } else { return variant(loc_.y+1); } } else if(key == "loc") { if (loc_==map_location::null_location) { return variant(); } else { return variant(new location_callable(loc_)); } } else if(key == "id") { return variant(u_.id()); } else if(key == "type") { return variant(u_.type_id()); } else if(key == "name") { return variant(u_.name()); } else if(key == "usage") { return variant(u_.usage()); } else if(key == "leader") { return variant(u_.can_recruit()); } else if(key == "undead") { return variant(u_.get_state("not_living") ? 1 : 0); } else if(key == "attacks") { const std::vector<attack_type>& att = u_.attacks(); std::vector<variant> res; for( std::vector<attack_type>::const_iterator i = att.begin(); i != att.end(); ++i) res.push_back(variant(new attack_type_callable(*i))); return variant(&res); } else if(key == "abilities") { std::vector<std::string> abilities = u_.get_ability_list(); std::vector<variant> res; if (abilities.empty()) return variant( &res ); for (std::vector<std::string>::iterator it = abilities.begin(); it != abilities.end(); ++it) { res.push_back( variant(*it) ); } return variant( &res ); } else if(key == "hitpoints") { return variant(u_.hitpoints()); } else if(key == "max_hitpoints") { return variant(u_.max_hitpoints()); } else if(key == "experience") { return variant(u_.experience()); } else if(key == "max_experience") { return variant(u_.max_experience()); } else if(key == "level") { return variant(u_.level()); } else if(key == "total_movement") { return variant(u_.total_movement()); } else if(key == "movement_left") { return variant(u_.movement_left()); } else if(key == "attacks_left") { return variant(u_.attacks_left()); } else if(key == "traits") { const std::vector<std::string> traits = u_.get_traits_list(); std::vector<variant> res; if(traits.empty()) return variant( &res ); for (std::vector<std::string>::const_iterator it = traits.begin(); it != traits.end(); ++it) { res.push_back( variant(*it) ); } return variant( &res ); } else if(key == "states") { const std::map<std::string, std::string>& states_map = u_.get_states(); return convert_map( states_map ); } else if(key == "side") { return variant(u_.side()-1); } else if(key == "cost") { return variant(u_.cost()); } else if(key == "vars") { if(u_.formula_vars()) { return variant(u_.formula_vars().get()); } else { return variant(); } } else { return variant(); } }
bool StencilAnalysis::isShareableReference(const std::vector<SgExpression*> subscripts, const bool corner_yz //=FALSE ) { //March 2 2011, made changes in the function, we have more robust sharing conditions //checks if an array reference can be replaced with shared memory reference //by looking at the index expressions //assumes the variable is already checked for candidacy //check if subsrcipts are _gidx, _gidy or _gidz std::vector<SgExpression*>::const_iterator it; size_t count = 0; int indexNo = 0; for(it= subscripts.begin(); it != subscripts.end(); it++) { indexNo++; SgExpression* index = isSgExpression(*it); Rose_STL_Container<SgNode*> varList = NodeQuery::querySubTree(index, V_SgVarRefExp); if(varList.size() != 1) //there should be only 1 variable and that should be gidx,y,z return false; //check if that varRef is x, y, z SgVarRefExp* varExp = isSgVarRefExp(*(varList.begin())); ROSE_ASSERT(varExp); string index_str = varExp->unparseToString(); if(indexNo == 1 && index_str != GIDX ) return false; if(indexNo == 2 && index_str != GIDY ) return false; if(indexNo == 3 && index_str != GIDZ ) return false; Rose_STL_Container<SgNode*> constList = NodeQuery::querySubTree(index, V_SgIntVal); if(constList.size() > 1 ) return false; if(constList.size() == 1) { SgIntVal* constVal = isSgIntVal(*(constList.begin())); ROSE_ASSERT(constVal); if(constVal->get_value() > MAX_ORDER) return false; //we keep maximum 3 planes in shared memory if(constVal->get_value() > 1 && indexNo == 3) return false; Rose_STL_Container<SgNode*> binOpList = NodeQuery::querySubTree(index, V_SgBinaryOp); if(binOpList.size() != 1) return false; SgBinaryOp* binOp = isSgBinaryOp(*(binOpList.begin())); //we want either one add or subtract operation in the index expression //no complex indexing is supported for now. //A[i+2][i-4] is valid but A[i*2] is not valid if( !isSgAddOp(binOp) && !isSgSubtractOp(binOp)) return false; if(indexNo == 3 && !corner_yz) { //corner of yz is only shareable when corner_yz is true return false; } } count++; } return (count == subscripts.size()) ? true : false ; }
bool MDNS::addService(String protocol, String service, uint16_t port, String instance, std::vector<String> subServices) { bool success = true; String status = "Ok"; if (!labels[HOSTNAME]) { status = "Hostname not set"; success = false; } if (success && protocol.length() < MAX_LABEL_SIZE - 1 && service.length() < MAX_LABEL_SIZE - 1 && instance.length() < MAX_LABEL_SIZE && isAlphaDigitHyphen(protocol) && isAlphaDigitHyphen(service) && isNetUnicode(instance)) { PTRRecord * ptrRecord = new PTRRecord(); SRVRecord * srvRecord = new SRVRecord(); txtRecord = new TXTRecord(); InstanceNSECRecord * instanceNSECRecord = new InstanceNSECRecord(); records.push_back(ptrRecord); records.push_back(srvRecord); records.push_back(txtRecord); records.push_back(instanceNSECRecord); String serviceString = "_" + service + "._" + protocol; Label * protocolLabel = new Label("_" + protocol, LOCAL); if (labels[serviceString] == NULL) { labels[serviceString] = new ServiceLabel(aRecord, "_" + service, protocolLabel); } ((ServiceLabel *) labels[serviceString])->addInstance(ptrRecord, srvRecord, txtRecord); String instanceString = instance + "._" + service + "._" + protocol; labels[instanceString] = new InstanceLabel(srvRecord, txtRecord, instanceNSECRecord, aRecord, instance, labels[serviceString], true); for (std::vector<String>::const_iterator i = subServices.begin(); i != subServices.end(); ++i) { String subServiceString = "_" + *i + "._sub." + serviceString; if (labels[subServiceString] == NULL) { labels[subServiceString] = new ServiceLabel(aRecord, "_" + *i, new Label("_sub", labels[serviceString])); } PTRRecord * subPTRRecord = new PTRRecord(); subPTRRecord->setLabel(labels[subServiceString]); subPTRRecord->setInstanceLabel(labels[instanceString]); records.push_back(subPTRRecord); ((ServiceLabel *) labels[subServiceString])->addInstance(subPTRRecord, srvRecord, txtRecord); } ptrRecord->setLabel(labels[serviceString]); ptrRecord->setInstanceLabel(labels[instanceString]); srvRecord->setLabel(labels[instanceString]); srvRecord->setPort(port); srvRecord->setHostLabel(labels[HOSTNAME]); txtRecord->setLabel(labels[instanceString]); instanceNSECRecord->setLabel(labels[instanceString]); } else { status = success? "Invalid name" : status; success = false; } return success; }
/** Test relation writing */ void testRelationWrite() { std::string left_name = "_x"; std::string right_name = "_y"; std::string field_left_name = "a"; std::string field_right_name = "b"; std::string field_left_val = "1"; std::string field_right_val = "2"; std::unordered_map<std::string, std::string> left_types, right_types; defpair e1Def, e2Def; valpair e1Val, e2Val; // setup test entity e1Def.push_back(std::make_pair(new IntegerColumn(), field_left_name)); e2Def.push_back(std::make_pair(new IntegerColumn(), field_right_name)); makeTestEntity(left_name, e1Def); makeTestEntity(right_name, e2Def); writeEntities(); e1Val.push_back(std::make_pair(field_left_name, field_left_val)); e2Val.push_back(std::make_pair(field_right_name, field_right_val)); left_types.insert(std::make_pair("a", COLTYPE_NAME_INT)); right_types.insert(std::make_pair("b", COLTYPE_NAME_INT)); makeTestRelation(left_name, right_name, e1Val, e2Val, left_types, right_types); writeRelations(); // Fetch the relation written IndexHandler ih; Json::Value json; std::string key; std::vector<std::string> keys; for (std::vector<Relation>::iterator it = openRelations.begin(); it != openRelations.end(); ++it) { ih.fetchRaw(it->generateKey(), json); keys.push_back(it->generateKey()); assert(std::strcmp(json[JSON_ATTR_REL_ENTL].asCString(), it->name_left.c_str()) == 0); assert(std::strcmp(json[JSON_ATTR_REL_ENTR].asCString(), it->name_right.c_str()) == 0); assert(json[JSON_ATTR_REL_FIELDSL].isMember(field_left_name)); assert(json[JSON_ATTR_REL_FIELDSR].isMember(field_right_name)); assert(json[JSON_ATTR_REL_FIELDSL][JSON_ATTR_FIELDS_COUNT].asInt() == 1); assert(json[JSON_ATTR_REL_FIELDSR][JSON_ATTR_FIELDS_COUNT].asInt() == 1); assert(std::strcmp(json[JSON_ATTR_REL_FIELDSL][ std::string(JSON_ATTR_REL_TYPE_PREFIX) + field_left_name]. asCString(), COLTYPE_NAME_INT) == 0); assert(std::strcmp(json[JSON_ATTR_REL_FIELDSR][ std::string(JSON_ATTR_REL_TYPE_PREFIX) + field_right_name]. asCString(), COLTYPE_NAME_INT) == 0); } for (defpair::iterator it = e1Def.begin() ; it != e1Def.end(); ++it) delete it->first; for (defpair::iterator it = e2Def.begin() ; it != e2Def.end(); ++it) delete it->first; // Cleanup removeEntities(); removeRelations(); releaseObjects(); // Test Removal for (std::vector<std::string>::iterator it = keys.begin() ; it != keys.end(); ++it) { json = Json::Value(); assert(!ih.fetchRaw(*it, json)); } }
void htmlWidgetTop7Categories::getTopCategoryStats( std::vector<std::pair<wxString, double> > &categoryStats , const mmDateRange* date_range) const { //Get base currency rates for all accounts std::map<int, double> acc_conv_rates; for (const auto& account: Model_Account::instance().all()) { Model_Currency::Data* currency = Model_Account::currency(account); acc_conv_rates[account.ACCOUNTID] = currency->BASECONVRATE; } //Temporary map std::map<std::pair<int /*category*/, int /*sub category*/>, double> stat; const auto splits = Model_Splittransaction::instance().get_all(); const auto &transactions = Model_Checking::instance().find( Model_Checking::TRANSDATE(date_range->start_date(), GREATER_OR_EQUAL) , Model_Checking::TRANSDATE(date_range->end_date(), LESS_OR_EQUAL) , Model_Checking::STATUS(Model_Checking::VOID_, NOT_EQUAL) , Model_Checking::TRANSCODE(Model_Checking::TRANSFER, NOT_EQUAL)); for (const auto &trx : transactions) { bool withdrawal = Model_Checking::type(trx) == Model_Checking::WITHDRAWAL; const auto it = splits.find(trx.TRANSID); if (it == splits.end()) { std::pair<int, int> category = std::make_pair(trx.CATEGID, trx.SUBCATEGID); if (withdrawal) stat[category] -= trx.TRANSAMOUNT * (acc_conv_rates[trx.ACCOUNTID]); else stat[category] += trx.TRANSAMOUNT * (acc_conv_rates[trx.ACCOUNTID]); } else { for (const auto& entry : it->second) { std::pair<int, int> category = std::make_pair(entry.CATEGID, entry.SUBCATEGID); double val = entry.SPLITTRANSAMOUNT * (acc_conv_rates[trx.ACCOUNTID]) * (withdrawal ? -1 : 1); stat[category] += val; } } } categoryStats.clear(); for (const auto& i : stat) { if (i.second < 0) { std::pair <wxString, double> stat_pair; stat_pair.first = Model_Category::full_name(i.first.first, i.first.second); stat_pair.second = i.second; categoryStats.push_back(stat_pair); } } std::stable_sort(categoryStats.begin(), categoryStats.end() , [] (const std::pair<wxString, double> x, const std::pair<wxString, double> y) { return x.second < y.second; } ); int counter = 0; std::vector<std::pair<wxString, double> >::iterator iter; for (iter = categoryStats.begin(); iter != categoryStats.end(); ) { counter++; if (counter > 7) iter = categoryStats.erase(iter); else ++iter; } }
~Allocator() { for(typename std::vector<T*>::iterator i = chunks_.begin(); i != chunks_.end(); ++i) { T* chunk = *i; delete[] chunk; } }
void ActivateStoneKeepers() { for (std::vector<uint64>::const_iterator i = vStoneKeeper.begin(); i != vStoneKeeper.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (!pTarget || !pTarget->isAlive() || pTarget->getFaction() == 14) continue; pTarget->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE); pTarget->setFaction(14); pTarget->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); return; // only want the first one we find } // if we get this far than all four are dead so open the door SetData (DATA_ALTAR_DOORS, DONE); SetDoor (uiArchaedasTempleDoor, true); //open next the door too }
/// runPasses - Run the specified passes on Program, outputting a bitcode file /// and writing the filename into OutputFile if successful. If the /// optimizations fail for some reason (optimizer crashes), return true, /// otherwise return false. If DeleteOutput is set to true, the bitcode is /// deleted on success, and the filename string is undefined. This prints to /// outs() a single line message indicating whether compilation was successful /// or failed. /// bool BugDriver::runPasses(Module *Program, const std::vector<std::string> &Passes, std::string &OutputFilename, bool DeleteOutput, bool Quiet, unsigned NumExtraArgs, const char * const *ExtraArgs) const { // setup the output file name outs().flush(); SmallString<128> UniqueFilename; error_code EC = sys::fs::createUniqueFile( OutputPrefix + "-output-%%%%%%%.bc", UniqueFilename); if (EC) { errs() << getToolName() << ": Error making unique filename: " << EC.message() << "\n"; return 1; } OutputFilename = UniqueFilename.str(); // set up the input file name SmallString<128> InputFilename; int InputFD; EC = sys::fs::createUniqueFile(OutputPrefix + "-input-%%%%%%%.bc", InputFD, InputFilename); if (EC) { errs() << getToolName() << ": Error making unique filename: " << EC.message() << "\n"; return 1; } tool_output_file InFile(InputFilename.c_str(), InputFD); WriteBitcodeToFile(Program, InFile.os()); InFile.os().close(); if (InFile.os().has_error()) { errs() << "Error writing bitcode file: " << InputFilename << "\n"; InFile.os().clear_error(); return 1; } std::string tool = OptCmd.empty()? sys::FindProgramByName("opt") : OptCmd; if (tool.empty()) { errs() << "Cannot find `opt' in PATH!\n"; return 1; } // Ok, everything that could go wrong before running opt is done. InFile.keep(); // setup the child process' arguments SmallVector<const char*, 8> Args; if (UseValgrind) { Args.push_back("valgrind"); Args.push_back("--error-exitcode=1"); Args.push_back("-q"); Args.push_back(tool.c_str()); } else Args.push_back(tool.c_str()); Args.push_back("-o"); Args.push_back(OutputFilename.c_str()); for (unsigned i = 0, e = OptArgs.size(); i != e; ++i) Args.push_back(OptArgs[i].c_str()); std::vector<std::string> pass_args; for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) { pass_args.push_back( std::string("-load")); pass_args.push_back( PluginLoader::getPlugin(i)); } for (std::vector<std::string>::const_iterator I = Passes.begin(), E = Passes.end(); I != E; ++I ) pass_args.push_back( std::string("-") + (*I) ); for (std::vector<std::string>::const_iterator I = pass_args.begin(), E = pass_args.end(); I != E; ++I ) Args.push_back(I->c_str()); Args.push_back(InputFilename.c_str()); for (unsigned i = 0; i < NumExtraArgs; ++i) Args.push_back(*ExtraArgs); Args.push_back(nullptr); DEBUG(errs() << "\nAbout to run:\t"; for (unsigned i = 0, e = Args.size()-1; i != e; ++i) errs() << " " << Args[i]; errs() << "\n"; );
void MissionControl::transmitPatches(const std::vector<katana::RoadBase::ConstPtr>& patches, u_int8_t status, u_int8_t number_of_stitches, u_int8_t patches_to_search, double matching_threshold) { if(status == (u_int8_t)PerceptionState::JUNCTION_AHEAD || status == (u_int8_t) PerceptionState::JUNCTION_AHEAD_AGAIN) { #ifdef KATANA_MC_PATCH_TRANSMIT_DEBUG std::cout << "MC: junction AHEAD transmitting to lanetracker. Tranmitting patches:" << std::endl; for(RoadBase::ConstPtr segment : patches) { std::cout << "Type: " << (u_int32_t)segment->getPatchType() << segment->getAnchorPose() << std::endl; } #endif m_transmit_patches_func(patches, status, number_of_stitches, patches_to_search, matching_threshold); } else { // If junction is detected then insert straight patches for perception std::vector<katana::RoadBase::ConstPtr> working_copy; for(std::vector<katana::RoadBase::ConstPtr>::const_iterator it = patches.begin(); it != patches.end(); ++it) { // Do not insert junctions or parking patches if((*it)->getPatchType() >= PatchType::JUNCTION) { #ifdef KATANA_MC_PATCH_TRANSMIT_DEBUG std::cout << "MC: skipping junction or parking patch to transmit" << std::endl; #endif } else { // Copy patch to working copy working_copy.push_back(*it); } } m_transmit_patches_func(working_copy, status, number_of_stitches, patches_to_search , matching_threshold); //m_transmit_patches_func(patches, status, 0, 0, -1.0); } }
/// @internal /// @brief Determine which tests need to be run and run them virtual void RunTests() { if (RunAutomaticTests==RunInteractiveTests && RunInteractiveTests==false) // enforce running automatic tests if no type of test is specified { RunAutomaticTests=true; } if (RunAll) { for(map<String,UnitTestGroup*>::iterator Iter=TestGroups.begin(); Iter!=TestGroups.end(); ++Iter) { TestGroupsToRun.push_back(Iter->first); } } if(ExecuteInThisMemorySpace) // Should we be executing the test right now? { for(std::vector<Mezzanine::String>::iterator CurrentTestName=TestGroupsToRun.begin(); CurrentTestName!=TestGroupsToRun.end(); ++CurrentTestName ) // Actually run the tests { try{ TestGroups[*CurrentTestName]->RunTests(RunAutomaticTests, RunInteractiveTests); } catch (std::exception e) { TestError << std::endl << e.what() << std::endl; // maybe we should log or somehting. } (*this) += *(TestGroups[*CurrentTestName]); } }else{ // No, We should be executing the test in a place that cannot possibly crash this program for(std::vector<Mezzanine::String>::iterator CurrentTestName=TestGroupsToRun.begin(); CurrentTestName!=TestGroupsToRun.end(); ++CurrentTestName ) { ClearTempFile(); if(system(String(CommandName + " " + *CurrentTestName + " " + MemSpaceArg + " " + Mezzanine::String(RunAutomaticTests?"automatic ":"") + Mezzanine::String(RunInteractiveTests?"interactive ":"")).c_str())) // Run a single unit test as another process { this->AddTestResult(String("Process::" + *CurrentTestName), Testing::Failed); }else { this->AddTestResult(String("Process::" + *CurrentTestName), Success); } try { (*this) += GetResultsFromTempFile(); } catch (std::exception& e) { TestError << e.what() << endl; } } DeleteTempFile(); } // \if(ExecuteInThisMemorySpace) } // \function
/** * Function TestForExistingItem * test if aItem exists somewhere in lists of items * This is a function used by PutDataInPreviousState to be sure an item was not deleted * since an undo or redo. * This could be possible: * - if a call to SaveCopyInUndoList was forgotten in Pcbnew * - in zones outlines, when a change in one zone merges this zone with an other * This function avoids a Pcbnew crash * Before using this function to test existence of items, * it must be called with aItem = NULL to prepare the list * @param aPcb = board to test * @param aItem = item to find * = NULL to build the list of existing items */ static bool TestForExistingItem( BOARD* aPcb, BOARD_ITEM* aItem ) { static std::vector<BOARD_ITEM*> itemsList; if( aItem == NULL ) // Build list { // Count items to store in itemsList: int icnt = 0; BOARD_ITEM* item; // Count tracks: for( item = aPcb->m_Track; item != NULL; item = item->Next() ) icnt++; // Count modules: for( item = aPcb->m_Modules; item != NULL; item = item->Next() ) icnt++; // Count drawings for( item = aPcb->m_Drawings; item != NULL; item = item->Next() ) icnt++; // Count zones outlines icnt += aPcb->GetAreaCount(); // Count zones segm (now obsolete): for( item = aPcb->m_Zone; item != NULL; item = item->Next() ) icnt++; // Build candidate list: itemsList.clear(); itemsList.reserve(icnt); // Store items in list: // Append tracks: for( item = aPcb->m_Track; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Append modules: for( item = aPcb->m_Modules; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Append drawings for( item = aPcb->m_Drawings; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Append zones outlines for( int ii = 0; ii < aPcb->GetAreaCount(); ii++ ) itemsList.push_back( aPcb->GetArea( ii ) ); // Append zones segm: for( item = aPcb->m_Zone; item != NULL; item = item->Next() ) itemsList.push_back( item ); // Sort list std::sort( itemsList.begin(), itemsList.end() ); return false; } // search in list: return std::binary_search( itemsList.begin(), itemsList.end(), aItem ); }
std::unique_ptr<Process> createSmallDeformationProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{process__type} config.checkConfigParameter("type", "SMALL_DEFORMATION_WITH_LIE"); DBUG("Create SmallDeformationProcess with LIE."); // Process variables auto const pv_conf = config.getConfigSubtree("process_variables"); auto range = pv_conf.getConfigParameterList<std::string>("process_variable"); std::vector<std::reference_wrapper<ProcessVariable>> process_variables; for (std::string const& pv_name : range) { if (pv_name != "displacement" && pv_name.find("displacement_jump")==std::string::npos) OGS_FATAL("Found a process variable name '%s'. It should be 'displacement' or 'displacement_jumpN'"); auto variable = std::find_if( variables.cbegin(), variables.cend(), [&pv_name](ProcessVariable const& v) { return v.getName() == pv_name; }); if (variable == variables.end()) { OGS_FATAL( "Could not find process variable '%s' in the provided variables " "list for config tag <%s>.", pv_name.c_str(), "process_variable"); } DBUG("Found process variable \'%s\' for config tag <%s>.", variable->getName().c_str(), "process_variable"); process_variables.emplace_back(const_cast<ProcessVariable&>(*variable)); } if (process_variables.size() > 2) OGS_FATAL("Currently only one displacement jump is supported"); DBUG("Associate displacement with process variable \'%s\'.", process_variables.back().get().getName().c_str()); if (process_variables.back().get().getNumberOfComponents() != DisplacementDim) { OGS_FATAL( "Number of components of the process variable '%s' is different " "from the displacement dimension: got %d, expected %d", process_variables.back().get().getName().c_str(), process_variables.back().get().getNumberOfComponents(), DisplacementDim); } // Constitutive relation. // read type; auto const constitutive_relation_config = //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__constitutive_relation} config.getConfigSubtree("constitutive_relation"); auto const type = constitutive_relation_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Solids::MechanicsBase<DisplacementDim>> material = nullptr; if (type == "LinearElasticIsotropic") { material = MaterialLib::Solids::createLinearElasticIsotropic<DisplacementDim>( parameters, constitutive_relation_config); } else { OGS_FATAL( "Cannot construct constitutive relation of given type \'%s\'.", type.c_str()); } // Fracture constitutive relation. // read type; auto const fracture_constitutive_relation_config = //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__constitutive_relation} config.getConfigSubtree("fracture_constitutive_relation"); auto const frac_type = fracture_constitutive_relation_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Fracture::FractureModelBase<DisplacementDim>> fracture_model = nullptr; if (frac_type == "LinearElasticIsotropic") { fracture_model = MaterialLib::Fracture::createLinearElasticIsotropic<DisplacementDim>( parameters, fracture_constitutive_relation_config); } else if (frac_type == "MohrCoulomb") { fracture_model = MaterialLib::Fracture::createMohrCoulomb<DisplacementDim>( parameters, fracture_constitutive_relation_config); } else { OGS_FATAL( "Cannot construct fracture constitutive relation of given type \'%s\'.", frac_type.c_str()); } // Fracture properties //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__fracture_properties} auto fracture_properties_config = config.getConfigSubtree("fracture_properties"); auto ¶_b0 = ProcessLib::findParameter<double>(fracture_properties_config, "initial_aperture", parameters, 1); std::unique_ptr<FractureProperty> frac_prop(new FractureProperty()); frac_prop->mat_id = fracture_properties_config.getConfigParameter<int>("material_id"); frac_prop->aperture0 = ¶_b0; SmallDeformationProcessData<DisplacementDim> process_data( std::move(material), std::move(fracture_model), std::move(frac_prop)); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"SmallDeformation_displacement"}); ProcessLib::parseSecondaryVariables(config, secondary_variables, named_function_caller); return std::unique_ptr<SmallDeformationProcess<DisplacementDim>>{ new SmallDeformationProcess<DisplacementDim>{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller)}}; }
void removeEntities() { RedisHandler rds(REDISDBTEST, REDISPORT); for (std::vector<Entity>::iterator it = openEntities.begin(); it != openEntities.end(); ++it) it->remove(rds); }
// used when Archaedas dies. All active minions must be despawned. void DeActivateMinions() { // first despawn any aggroed wall minions for (std::vector<uint64>::const_iterator i = vArchaedasWallMinions.begin(); i != vArchaedasWallMinions.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (!pTarget || pTarget->isDead() || pTarget->getFaction() != 14) continue; pTarget->setDeathState(JUST_DIED); pTarget->RemoveCorpse(); } // Vault Walkers for (std::vector<uint64>::const_iterator i = vVaultWalker.begin(); i != vVaultWalker.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (!pTarget || pTarget->isDead() || pTarget->getFaction() != 14) continue; pTarget->setDeathState(JUST_DIED); pTarget->RemoveCorpse(); } // Earthen Guardians for (std::vector<uint64>::const_iterator i = vEarthenGuardian.begin(); i != vEarthenGuardian.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (!pTarget || pTarget->isDead() || pTarget->getFaction() != 14) continue; pTarget->setDeathState(JUST_DIED); pTarget->RemoveCorpse(); } }
void removeRelations() { RedisHandler rds(REDISDBTEST, REDISPORT); for (std::vector<Relation>::iterator it = openRelations.begin(); it != openRelations.end(); ++it) it->remove(rds); }
void RespawnMinions() { // first respawn any aggroed wall minions for (std::vector<uint64>::const_iterator i = vArchaedasWallMinions.begin(); i != vArchaedasWallMinions.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (pTarget && pTarget->isDead()) { pTarget->Respawn(); pTarget->GetMotionMaster()->MoveTargetedHome(); SetFrozenState(pTarget); } } // Vault Walkers for (std::vector<uint64>::const_iterator i = vVaultWalker.begin(); i != vVaultWalker.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (pTarget && pTarget->isDead()) { pTarget->Respawn(); pTarget->GetMotionMaster()->MoveTargetedHome(); SetFrozenState(pTarget); } } // Earthen Guardians for (std::vector<uint64>::const_iterator i = vEarthenGuardian.begin(); i != vEarthenGuardian.end(); ++i) { Creature *pTarget = instance->GetCreature(*i); if (pTarget && pTarget->isDead()) { pTarget->Respawn(); pTarget->GetMotionMaster()->MoveTargetedHome(); SetFrozenState(pTarget); } } }
explicit test_id(std::vector<int> const& v_id) : first(v_id.begin()), last(v_id.end()){}
void Demux::populate_pvr_streams() { CLockObject Lock(m_mutex); uint16_t mainPid = 0xffff; int mainType = XBMC_CODEC_TYPE_UNKNOWN; std::vector<XbmcPvrStream> new_streams; const std::vector<ElementaryStream*> es_streams = m_AVContext->GetStreams(); for (std::vector<ElementaryStream*>::const_iterator it = es_streams.begin(); it != es_streams.end(); it++) { const char* codec_name = (*it)->GetStreamCodecName(); xbmc_codec_t codec = CODEC->GetCodecByName(codec_name); if (codec.codec_type != XBMC_CODEC_TYPE_UNKNOWN) { // Find the main stream: // The best candidate would be the first video. Else the first audio switch (mainType) { case XBMC_CODEC_TYPE_VIDEO: break; case XBMC_CODEC_TYPE_AUDIO: if (codec.codec_type != XBMC_CODEC_TYPE_VIDEO) break; default: mainPid = (*it)->pid; mainType = codec.codec_type; } XbmcPvrStream new_stream; m_streams.GetStreamData((*it)->pid, &new_stream); new_stream.iCodecId = codec.codec_id; new_stream.iCodecType = codec.codec_type; recode_language((*it)->stream_info.language, new_stream.strLanguage); new_stream.iIdentifier = stream_identifier((*it)->stream_info.composition_id, (*it)->stream_info.ancillary_id); new_stream.iFPSScale = (*it)->stream_info.fps_scale; new_stream.iFPSRate = (*it)->stream_info.fps_rate; new_stream.iHeight = (*it)->stream_info.height; new_stream.iWidth = (*it)->stream_info.width; new_stream.fAspect = (*it)->stream_info.aspect; new_stream.iChannels = (*it)->stream_info.channels; new_stream.iSampleRate = (*it)->stream_info.sample_rate; new_stream.iBlockAlign = (*it)->stream_info.block_align; new_stream.iBitRate = (*it)->stream_info.bit_rate; new_stream.iBitsPerSample = (*it)->stream_info.bits_Per_sample; new_streams.push_back(new_stream); m_AVContext->StartStreaming((*it)->pid); // Add stream to no setup set if (!(*it)->has_stream_info) m_nosetup.insert((*it)->pid); if (g_bExtraDebug) XBMC->Log(LOG_DEBUG, LOGTAG"%s: register PES %.4x %s", __FUNCTION__, (*it)->pid, codec_name); } } m_streams.UpdateStreams(new_streams); // Renew main stream m_mainStreamPID = mainPid; }
int StencilAnalysis::getSharingCategory(const std::vector<SgExpression*> subscripts) { //return 2 if it is up or down //return 1 if it is off-center //return 0 if it is center //return -1 if it is neither //check if subsrcipts are _gidx, _gidy or _gidz std::vector<SgExpression*>::const_iterator it; size_t count = 0; int indexNo = 0; size_t category = 0; for(it= subscripts.begin(); it != subscripts.end(); it++) { indexNo++; SgExpression* index = isSgExpression(*it); Rose_STL_Container<SgNode*> varList = NodeQuery::querySubTree(index, V_SgVarRefExp); if(varList.size() != 1) //there should be only 1 variable and that should be gidx,y,z return -1; //check if that varRef is x, y, z SgVarRefExp* varExp = isSgVarRefExp(*(varList.begin())); ROSE_ASSERT(varExp); string index_str = varExp->unparseToString(); if(indexNo == 1 && index_str != GIDX ) return -1; else if(indexNo == 2 && index_str != GIDY ) return -1; else if(indexNo == 3 && index_str != GIDZ ) return -1; Rose_STL_Container<SgNode*> constList = NodeQuery::querySubTree(index, V_SgIntVal); if(constList.size() > 1 ) return -1; if(constList.size() == 1) { category = 1; SgIntVal* constVal = isSgIntVal(*(constList.begin())); ROSE_ASSERT(constVal); if(constVal->get_value() > MAX_ORDER) return -1; //we keep maximum 3 planes in shared memory if(constVal->get_value() > 1 && indexNo == 3) return -1; Rose_STL_Container<SgNode*> binOpList = NodeQuery::querySubTree(index, V_SgBinaryOp); if(binOpList.size() != 1) return -1; SgBinaryOp* binOp = isSgBinaryOp(*(binOpList.begin())); //we want either one add or subtract operation in the index expression //no complex indexing is supported for now. //A[i+2][i-4] is valid but A[i*2] is not valid if( !isSgAddOp(binOp) && !isSgSubtractOp(binOp)) return -1; if(indexNo == 3) { category = 2; } } count++; } return (count == subscripts.size()) ? category : -1 ; }
void Scene::printObjects() { for (auto iter = mObjects.begin(); iter != mObjects.end(); ++iter) std::cout << (*iter) << std::endl; }
PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue) { Measure* measure = (Measure*)data; // Data is stored in two structs: Measure and ParentMeasure. ParentMeasure is created for measures // with PlayerName=someplayer. Measure is created for all measures and points to ParentMeasure as // referenced in PlayerName=[section]. // Read settings from the ini-file void* skin = RmGetSkin(rm); LPCWSTR str = RmReadString(rm, L"PlayerName", L"", FALSE); if (str[0] == L'[') { if (measure->parent) { // Don't let a measure measure change its parent } else { // PlayerName starts with [ so use referenced section ++str; int len = static_cast<int>(wcslen(str)); if (len > 0 && str[len - 1] == L']') { --len; std::vector<ParentMeasure*>::iterator iter = g_ParentMeasures.begin(); for ( ; iter != g_ParentMeasures.end(); ++iter) { if (skin == (*iter)->skin && wcsncmp(str, (*iter)->ownerName, len) == 0) { // Use same ParentMeasure as referenced section measure->parent = (*iter); ++measure->parent->measureCount; break; } } if (!measure->parent) { // The referenced section doesn't exist std::wstring error = L"NowPlaying.dll: Invalid PlayerName="; error.append(str - 1, len + 2); error += L" in ["; error += RmGetMeasureName(rm); error += L"]"; RmLog(LOG_WARNING, error.c_str()); return; } } } } else { // ParentMeasure is created when PlayerName is an actual player (and not a reference) ParentMeasure* parent = measure->parent; Player* oldPlayer = nullptr; if (parent) { if (parent->data != data) { // Don't let a measure-only measure become a parent measure return; } oldPlayer = parent->player; } else { parent = new ParentMeasure; g_ParentMeasures.push_back(parent); parent->data = data; parent->skin = skin; parent->ownerName = RmGetMeasureName(rm); measure->parent = parent; } if (_wcsicmp(L"AIMP", str) == 0) { parent->player = PlayerAIMP::Create(); } else if (_wcsicmp(L"CAD", str) == 0) { parent->player = PlayerCAD::Create(); } else if (_wcsicmp(L"foobar2000", str) == 0) { HWND fooWindow = FindWindow(L"foo_rainmeter_class", nullptr); if (fooWindow) { const WCHAR* error = L"Your foobar2000 plugin is out of date.\n\nDo you want to update the plugin now?"; if (MessageBox(nullptr, error, L"Rainmeter", MB_YESNO | MB_ICONINFORMATION | MB_TOPMOST) == IDYES) { ShellExecute(nullptr, L"open", L"http://github.com/poiru/foo-cad#readme", nullptr, nullptr, SW_SHOWNORMAL); } } parent->player = PlayerCAD::Create(); } else if (_wcsicmp(L"iTunes", str) == 0) { parent->player = PlayerITunes::Create(); } else if (_wcsicmp(L"MediaMonkey", str) == 0) { parent->player = PlayerWinamp::Create(WA_MEDIAMONKEY); } else if (_wcsicmp(L"Spotify", str) == 0) { parent->player = PlayerSpotify::Create(); } else if (_wcsicmp(L"WinAmp", str) == 0) { parent->player = PlayerWinamp::Create(WA_WINAMP); } else if (_wcsicmp(L"WMP", str) == 0) { parent->player = PlayerWMP::Create(); } else { // Default to WLM parent->player = PlayerWLM::Create(); if (_wcsicmp(L"WLM", str) != 0) { std::wstring error = L"NowPlaying.dll: Invalid PlayerName="; error += str; error += L" in ["; error += parent->ownerName; error += L"]"; RmLog(LOG_ERROR, error.c_str()); } } parent->player->AddInstance(); parent->playerPath = RmReadString(rm, L"PlayerPath", L""); parent->trackChangeAction = RmReadString(rm, L"TrackChangeAction", L"", FALSE); parent->disableLeadingZero = RmReadInt(rm, L"DisableLeadingZero", 0); if (oldPlayer) { parent->player->SetMeasures(oldPlayer->GetMeasures()); // Remove instance here so that player doesn't have to reinitialize if PlayerName was // not changed. oldPlayer->RemoveInstance(); } } str = RmReadString(rm, L"PlayerType", L""); if (_wcsicmp(L"ARTIST", str) == 0) { measure->type = MEASURE_ARTIST; } else if (_wcsicmp(L"TITLE", str) == 0) { measure->type = MEASURE_TITLE; } else if (_wcsicmp(L"ALBUM", str) == 0) { measure->type = MEASURE_ALBUM; } else if (_wcsicmp(L"COVER", str) == 0) { measure->type = MEASURE_COVER; } else if (_wcsicmp(L"DURATION", str) == 0) { measure->type = MEASURE_DURATION; } else if (_wcsicmp(L"POSITION", str) == 0) { measure->type = MEASURE_POSITION; } else if (_wcsicmp(L"PROGRESS", str) == 0) { measure->type = MEASURE_PROGRESS; *maxValue = 100.0; } else if (_wcsicmp(L"RATING", str) == 0) { measure->type = MEASURE_RATING; *maxValue = 5.0; } else if (_wcsicmp(L"STATE", str) == 0) { measure->type = MEASURE_STATE; } else if (_wcsicmp(L"STATUS", str) == 0) { measure->type = MEASURE_STATUS; } else if (_wcsicmp(L"VOLUME", str) == 0) { measure->type = MEASURE_VOLUME; *maxValue = 100.0; } else if (_wcsicmp(L"SHUFFLE", str) == 0) { measure->type = MEASURE_SHUFFLE; } else if (_wcsicmp(L"REPEAT", str) == 0) { measure->type = MEASURE_REPEAT; } else if (_wcsicmp(L"LYRICS", str) == 0) { RmLog(LOG_WARNING, L"NowPlaying.dll: Using undocumented PlayerType=LYRICS!"); measure->type = MEASURE_LYRICS; } else if (_wcsicmp(L"FILE", str) == 0) { measure->type = MEASURE_FILE; } else if (_wcsicmp(L"NUMBER", str) == 0) { measure->type = MEASURE_NUMBER; } else if (_wcsicmp(L"YEAR", str) == 0) { measure->type = MEASURE_YEAR; } else { std::wstring error = L"NowPlaying.dll: Invalid PlayerType="; error += str; error += L" in ["; error += RmGetMeasureName(rm); error += L"]"; RmLog(LOG_WARNING, error.c_str()); } measure->parent->player->AddMeasure(measure->type); }
void ActivateWallMinions() { Creature* archaedas = instance->GetCreature(archaedasGUID); if (!archaedas) return; for (std::vector<uint64>::const_iterator i = archaedasWallMinions.begin(); i != archaedasWallMinions.end(); ++i) { Creature* pTarget = instance->GetCreature(*i); if (!pTarget || !pTarget->isAlive() || pTarget->getFaction() == 14) continue; archaedas->CastSpell(pTarget, SPELL_AWAKEN_VAULT_WALKER, true); pTarget->CastSpell(pTarget, SPELL_ARCHAEDAS_AWAKEN,true); return; // only want the first one we find } }
void remove_sink( sink* s ) { auto it = std::find( global_sinks.begin(), global_sinks.end(), s ); if ( it != global_sinks.end() ) global_sinks.erase( it ); get_global_log_level(); }
void printOpenRelations() { for (std::vector<Relation>::iterator it = openRelations.begin(); it != openRelations.end(); ++it) cout << it->stringify() << endl; }
game_info::game_info(const config& game, const config& game_config, const std::vector<std::string>& installed_addons) : mini_map() , id(game["id"]) , map_data(game["map_data"]) , name(game["name"]) , scenario() , remote_scenario(false) , map_info() , map_size_info() , era() , era_short() , gold(game["mp_village_gold"]) , support(game["mp_village_support"]) , xp(game["experience_modifier"].str() + "%") , vision() , status() , time_limit() , vacant_slots(lexical_cast_default<int>(game["slots"], 0)) // Can't use to_int() here. , current_turn(0) , reloaded(game["savegame"].to_bool()) , started(false) , fog(game["mp_fog"].to_bool()) , shroud(game["mp_shroud"].to_bool()) , observers(game["observer"].to_bool(true)) , shuffle_sides(game["shuffle_sides"].to_bool(true)) , use_map_settings(game["mp_use_map_settings"].to_bool()) , registered_users_only(game["registered_users_only"].to_bool()) , verified(true) , password_required(game["password"].to_bool()) , have_era(true) , have_all_mods(true) , has_friends(false) , has_ignored(false) , display_status(NEW) , required_addons() , addons_outcome(SATISFIED) { const auto parse_requirements = [&](const config& c, const std::string& id_key) { if(c.has_attribute(id_key)) { if(std::find(installed_addons.begin(), installed_addons.end(), c[id_key].str()) == installed_addons.end()) { required_addon r; r.addon_id = c[id_key].str(); r.outcome = NEED_DOWNLOAD; r.message = vgettext("Missing addon: $id", {{"id", c[id_key].str()}}); required_addons.push_back(r); if(addons_outcome == SATISFIED) { addons_outcome = NEED_DOWNLOAD; } } } }; for(const config& addon : game.child_range("addon")) { parse_requirements(addon, "id"); } /* * Modifications have a different format than addons. The id and addon_id are keys sent by the * server, so we have to parse them separately here and add them to the required_addons vector. */ for(const config& mod : game.child_range("modification")) { parse_requirements(mod, "addon_id"); } std::string turn = game["turn"]; if(!game["mp_era"].empty()) { const config& era_cfg = game_config.find_child("era", "id", game["mp_era"]); if(era_cfg) { era = era_cfg["name"].str(); era_short = era_cfg["short_name"].str(); if(era_short.empty()) { era_short = make_short_name(era); } ADDON_REQ result = check_addon_version_compatibility(era_cfg, game); addons_outcome = std::max(addons_outcome, result); // Elevate to most severe error level encountered so far } else { have_era = !game["require_era"].to_bool(true); era = vgettext("Unknown era: $era_id", {{"era_id", game["mp_era_addon_id"].str()}}); era_short = make_short_name(era); verified = false; addons_outcome = NEED_DOWNLOAD; } } else { era = _("Unknown era"); era_short = "??"; verified = false; } std::stringstream info_stream; info_stream << era; if(!game.child_or_empty("modification").empty()) { for(const config& cfg : game.child_range("modification")) { if(const config& mod = game_config.find_child("modification", "id", cfg["id"])) { mod_info += (mod_info.empty() ? "" : ", ") + mod["name"].str(); if(cfg["require_modification"].to_bool(false)) { ADDON_REQ result = check_addon_version_compatibility(mod, game); addons_outcome = std::max(addons_outcome, result); // Elevate to most severe error level encountered so far } } else { mod_info += (mod_info.empty() ? "" : ", ") + cfg["addon_id"].str(); if(cfg["require_modification"].to_bool(false)) { have_all_mods = false; mod_info += " " + _("(missing)"); addons_outcome = NEED_DOWNLOAD; } } } } if(map_data.empty()) { map_data = filesystem::read_map(game["mp_scenario"]); } if(map_data.empty()) { info_stream << " — ??×??"; } else { try { gamemap map(std::make_shared<terrain_type_data>(game_config), map_data); // mini_map = image::getMinimap(minimap_size_, minimap_size_, map, // 0); std::ostringstream msi; msi << map.w() << font::unicode_multiplication_sign << map.h(); map_size_info = msi.str(); info_stream << " — " + map_size_info; } catch(incorrect_map_format_error& e) { ERR_CF << "illegal map: " << e.message << std::endl; verified = false; } catch(wml_exception& e) { ERR_CF << "map could not be loaded: " << e.dev_message << '\n'; verified = false; } } info_stream << " "; // // Check scenarios and campaigns // if(!game["mp_scenario"].empty() && game["mp_campaign"].empty()) { // Check if it's a multiplayer scenario const config* level_cfg = &game_config.find_child("multiplayer", "id", game["mp_scenario"]); // Check if it's a user map if(!*level_cfg) { level_cfg = &game_config.find_child("generic_multiplayer", "id", game["mp_scenario"]); } if(*level_cfg) { scenario = formatter() << "<b>" << _("(S)") << "</b>" << " " << (*level_cfg)["name"].str(); info_stream << scenario; // Reloaded games do not match the original scenario hash, so it makes no sense // to test them, since they always would appear as remote scenarios if(!reloaded) { if(const config& hashes = game_config.child("multiplayer_hashes")) { std::string hash = game["hash"]; bool hash_found = false; for(const auto & i : hashes.attribute_range()) { if(i.first == game["mp_scenario"] && i.second == hash) { hash_found = true; break; } } if(!hash_found) { remote_scenario = true; info_stream << " — "; info_stream << _("Remote scenario"); verified = false; } } } if((*level_cfg)["require_scenario"].to_bool(false)) { ADDON_REQ result = check_addon_version_compatibility((*level_cfg), game); addons_outcome = std::max(addons_outcome, result); // Elevate to most severe error level encountered so far } } else { scenario = vgettext("Unknown scenario: $scenario_id", {{"scenario_id", game["mp_scenario_name"].str()}}); info_stream << scenario; verified = false; } } else if(!game["mp_campaign"].empty()) { if(const config& level_cfg = game_config.find_child("campaign", "id", game["mp_campaign"])) { std::stringstream campaign_text; campaign_text << "<b>" << _("(C)") << "</b>" << " " << level_cfg["name"] << " — " << game["mp_scenario_name"]; // Difficulty config difficulties = gui2::dialogs::generate_difficulty_config(level_cfg); for(const config& difficulty : difficulties.child_range("difficulty")) { if(difficulty["define"] == game["difficulty_define"]) { campaign_text << " — " << difficulty["description"]; break; } } scenario = campaign_text.str(); info_stream << campaign_text.rdbuf(); // TODO: should we have this? //if(game["require_scenario"].to_bool(false)) { ADDON_REQ result = check_addon_version_compatibility(level_cfg, game); addons_outcome = std::max(addons_outcome, result); // Elevate to most severe error level encountered so far //} } else { scenario = vgettext("Unknown campaign: $campaign_id", {{"campaign_id", game["mp_campaign"].str()}}); info_stream << scenario; verified = false; } } else { scenario = _("Unknown scenario"); info_stream << scenario; verified = false; } // Remove any newlines that might have been in game titles boost::replace_all(scenario, "\n", " " + font::unicode_em_dash + " "); if(reloaded) { info_stream << " — "; info_stream << _("Reloaded game"); verified = false; } if(!turn.empty()) { started = true; int index = turn.find_first_of('/'); if(index > -1) { const std::string current_turn_string = turn.substr(0, index); current_turn = lexical_cast<unsigned int>(current_turn_string); } status = _("Turn") + " " + turn; } else { started = false; if(vacant_slots > 0) { status = _n("Vacant Slot:", "Vacant Slots:", vacant_slots) + " " + game["slots"]; } } if(fog) { vision = _("Fog"); if(shroud) { vision += "/"; vision += _("Shroud"); } } else if(shroud) { vision = _("Shroud"); } else { vision = _("none"); } if(game["mp_countdown"].to_bool()) { time_limit = formatter() << game["mp_countdown_init_time"].str() << "+" << game["mp_countdown_turn_bonus"].str() << "/" << game["mp_countdown_action_bonus"].str(); } map_info = info_stream.str(); }
void printOpenEntities() { for (std::vector<Entity>::iterator it = openEntities.begin(); it != openEntities.end(); ++it) cout << it->stringify() << endl; }
size_t stumpd::insert::insert_data(std::vector <std::vector <std::string> > data) { fprintf(stdout, "insert_data size %ld\n", data.size()); FILE *fp; size_t document_count; document_count = 0; bool start; start = 1; char *ymd; ymd = (char*)calloc(sizeof(char), 10); char *ymd_old; ymd_old = (char*)calloc(sizeof(char), 10); struct tm *date_buf; date_buf = (struct tm*)calloc(sizeof(struct tm), 1); if(strcmp(DB_TYPE, "mysql") == 0) { std::string insert_query("START TRANSACTION;"); std::vector <std::vector < std::string > > results; if(data.size() > 0) std::sort(data.begin(), data.end(), sort_dates); size_t i; time_t str_to_date; for(i=0;i<data.size();i++) { str_to_date = strtol(data[i][0].c_str(), NULL, 0); localtime_r(&str_to_date, date_buf); strftime(ymd, 10, "%Y%m%d", date_buf); if(strcmp(ymd, ymd_old) != 0) { if(strlen(ymd_old) != 0) { //fprintf(stdout, "ymd_old length is %ld\n", strlen(ymd_old)); insert_query.erase(insert_query.length() - 1); insert_query.append(";"); } else { if(i<data.size()-1&&start == 0) insert_query.append(","); } fprintf(stdout, "Starting new insert query, capping off the last one\n"); start = 1; } if(start == 1) { strncpy(ymd_old, ymd, 10); //insert_query.clear(); insert_query .append("INSERT INTO `documents_") .append( std::string(ymd) .substr(0, 4)) .append("`.`") .append(ymd) .append("` (date, host, input, content) VALUES "); start = !start; } insert_query .append("(FROM_UNIXTIME(") .append(data[i][0]) .append("),'") .append(data[i][1]) .append("','") .append(data[i][2]) .append("','") .append(data[i][3]) .append("')"); if(i<data.size()-1&&start == 0) insert_query.append(","); } insert_query .append(";COMMIT;"); fp = fopen("/tmp/insert.log", "w+"); fprintf(fp, "%s", insert_query.c_str()); fclose(fp); results = mysql_conn->query(insert_query.c_str()); free(ymd); free(ymd_old); if(results.size() == 0) return 1; else return 0; } else if(strcmp(DB_TYPE, "clucene") == 0) { free(ymd); free(ymd_old); fprintf(stderr, "CLucene DB_TYPE is not yet supported\n"); return 0; } free(ymd); free(ymd_old); return document_count; }
void AddItems( std::vector< boost::shared_ptr<GameItem> >& pItems ) { if( pItems.empty() ) return; m_pProperty.insert( m_pProperty.end(), pItems.begin(), pItems.end() ); }