bool World::CalculatePath(Vector &start, Vector &finish, std::vector<Vector> &path) { Tile *start_tile = GetTile(start); if(!start_tile) { return false; } Tile *finish_tile = GetTile(finish); if(!finish_tile) { return false; } bool result = TileMap::CalculatePath(start_tile, finish_tile); if(result) { for(Tile *tile = GetTile(finish); tile; tile = tile->GetParent()) { path.emplace(path.begin(), (TileW * tile->GetX()) + (TileW / 2), (TileH * tile->GetY()) + (TileH / 2) ); } } return result; }
/// <summary> /// Generate assembly code for remote call. /// </summary> /// <param name="a">Underlying assembler object</param> /// <param name="pfn">Remote function pointer</param> /// <param name="args">Function arguments</param> /// <param name="cc">Calling convention</param> /// <param name="retType">Return type</param> /// <returns>true on success</returns> bool RemoteExec::PrepareCallAssembly( AsmHelperBase& a, const void* pfn, std::vector<AsmVariant>& args, eCalligConvention cc, eReturnType retType ) { size_t data_offset = ARGS_OFFSET; // Invalid calling convention if (cc < cc_cdecl || cc > cc_fastcall) { LastNtStatus( STATUS_INVALID_PARAMETER_3 ); return false; } // Copy structures and strings for (auto& arg : args) { if (arg.type == AsmVariant::dataStruct || arg.type == AsmVariant::dataPtr) { _userData.Write( data_offset, arg.size, reinterpret_cast<const void*>(arg.imm_val) ); arg.new_imm_val = _userData.ptr<size_t>() + data_offset; // Add some padding after data data_offset += arg.size + 0x10; } } // Insert hidden variable if return type is struct. // This variable contains address of buffer in which return value is copied if (retType == rt_struct) { args.emplace( args.begin(), AsmVariant( _userData.ptr<size_t>() + ARGS_OFFSET ) ); args.front().new_imm_val = args.front().imm_val; args.front().type = AsmVariant::structRet; } a.GenPrologue(); a.GenCall( pfn, args, cc ); // Retrieve result from XMM0 or ST0 if (retType == rt_float || retType == rt_double) { a->mov( asmjit::host::zax, _userData.ptr<size_t>() + RET_OFFSET ); #ifdef USE64 if (retType == rt_double) a->movsd( asmjit::host::Mem( asmjit::host::zax, 0 ), asmjit::host::xmm0 ); else a->movss( asmjit::host::Mem( asmjit::host::zax, 0 ), asmjit::host::xmm0 ); #else a->fstp( asmjit::host::Mem( asmjit::host::zax, 0, retType * sizeof(float) ) ); #endif } AddReturnWithEvent( a, mt_default, retType ); a.GenEpilogue(); return true; }
void CAddonDatabase::GetInstalled(std::vector<CAddonBuilder>& addons) { try { if (NULL == m_pDB.get()) return; if (NULL == m_pDS.get()) return; m_pDS->query(PrepareSQL("SELECT * FROM installed")); while (!m_pDS->eof()) { auto it = addons.emplace(addons.end()); it->SetId(m_pDS->fv("addonID").get_asString()); it->SetInstallDate(CDateTime::FromDBDateTime(m_pDS->fv("installDate").get_asString())); it->SetLastUpdated(CDateTime::FromDBDateTime(m_pDS->fv("lastUpdated").get_asString())); it->SetLastUsed(CDateTime::FromDBDateTime(m_pDS->fv("lastUsed").get_asString())); it->SetOrigin(m_pDS->fv("origin").get_asString()); m_pDS->next(); } m_pDS->close(); } catch (...) { CLog::Log(LOGERROR, "%s failed", __FUNCTION__); } }
void emplace(Args&&... args) { detail::is_component<T>(); std::unique_ptr<Component> c{ new T(std::forward<Args>(args)...) }; auto&& id = std::type_index(typeid(T)); auto&& it = find(id); components.emplace(it, id, std::move(c)); }
std::vector<std::vector<int>> minesweeper(std::vector<std::vector<bool>> matrix) { int x = matrix[0].size(); int y = matrix.size(); std::vector<bool> m_allFalse(x + 2); std::vector<std::vector<int>> r; for(int i = 0;i < matrix.size();i++){ matrix[i].emplace(matrix[i].begin(), 0); matrix[i].push_back(0); } matrix.emplace(matrix.begin(), m_allFalse); matrix.push_back(m_allFalse); for(int i = 1; i < matrix.size() - 1;i++){ std::vector<int> q(x); for(int j = 1; j < matrix[0].size();j++){ for(int a = i - 1;a < i + 2;a++) for(int b = j - 1;b < j + 2;b++){ if(matrix[a][b]) q[j - 1]++; } if(matrix[i][j]) q[j - 1]--; } r.push_back(q); } return r; }
void insertInitListProxy(std::vector<VecT> & Cnt, Iterator pos, std::initializer_list<LType> il) { // pre-allocate space Cnt.reserve(Cnt.size() + il.size()); // construct the items in-place for (auto it = il.begin(); it < il.end(); ++it) pos = Cnt.emplace(pos, *it) + 1; }
inline void taPushFront(const T& mX) { // Instant data.emplace(std::begin(data), mX); auto& ts(create<TextSquare>(ssvs::zeroVec2f)); auto xStr(ssvu::toStr(mX)); // Timed this->createTA() += [this, &ts](auto&, FT) { tss.emplace(std::begin(tss), &ts); }; this->createTA() += [this](auto&, FT) { this->refreshPositions(); }; ts.taShow(); ts = xStr; }
void insertInitListProxy(std::vector<VecT> & Cnt, Iterator pos, std::initializer_list<LType> il) { // save iterator 'distance' from begin() in case a resize operation happens auto diff = pos - Cnt.begin(); // pre-allocate space Cnt.reserve(Cnt.size() + il.size()); // reset iterator based on any changes that occurred due to a resize // from here on out, we don't need to worry about resizes pos = Cnt.begin() + diff; // construct the items in-place for (auto it = il.begin(); it < il.end(); ++it) { pos = Cnt.emplace(pos, *it); ++pos; // move to position *after* what was just inserted } }
void itemCreated(const std::string& file) { auto it = std::lower_bound(m_dirEntries.begin(), m_dirEntries.end(), file, Cmp()); it = m_dirEntries.emplace(it, file); std::string filePatch = m_dir.path(); if (!endsWith(filePatch, '/')) filePatch.push_back('/'); filePatch.append(file); if (stat64(filePatch.c_str(), &it->info) == -1) { m_dirEntries.erase(it); return; } q->itemInserted(it - m_dirEntries.begin()); }
CXIdxClientContainer updateClientContainer(const CXIdxEntityInfo* info, const CXIdxLoc l) { std::string container; if (info->name) container = info->name; else container = "<anonymous-tag>"; // location loc = {l}; auto result = std::string{loc.file().toLocalFile().toUtf8().constData()} + ":" + std::to_string(loc.line()) + ":" + std::to_string(loc.column()) + ": " + container ; auto& ptr = *m_containers.emplace(end(m_containers), new std::string(std::move(result))); return CXIdxClientContainer(ptr.get()); }
inline static void run(std::vector<T> &c, std::size_t size) { for(std::size_t i=0; i<size; ++i) { c.emplace(begin(c)); } }
void bad_emplace_vector1(std::vector<int> &V, int n) { auto i1 = V.cbegin(), i0 = i1++; V.emplace(i1, n); *i1; // expected-warning{{Invalidated iterator accessed}} }
void addAt(T value, size_t loc = 0) { m->emplace(m.begin() + loc, value); }
void good_emplace_vector1(std::vector<int> &V, int n) { auto i1 = V.cbegin(), i0 = i1++; V.emplace(i1, n); *i0; // no-warning }
void greedy_path() { //cout << "Inside funciton "; std::unordered_set<int> s; while (s.size() < 3) { //cout << "In while"; srand(time(NULL)); s.insert(rand()%count);///or count-1????? } //int path[num_cities+2]; int k=0; //std::vector<int>::iterator k; //k = path.begin(); std::unordered_set<int>::iterator it; for(it=s.begin();it!=s.end();++it) { //path[k]=*it; //cout << *it << " "; path.push_back(*it); k++; //path.emplace(k,*it); //k++; } it=s.begin(); double d1,d2,d3; int m;double cost,minCost; path.push_back(*it); k++; //auto iit=path.begin(); //while(iit != path.end()) //{ // cout << *iit << " "; // ++iit; //} //cout << endl; // cout << "HI" << endl; //path.emplace(k++,*it); /*from here!! for(int i=1;i<count;i++) { //cout << "Inside loop" << " "; bool found = false; for(auto k1=path.begin();k1!=path.end();k1++) { if(*k1 == i) { found = true; break; } } if(found == false) { // cout << "Inside false if "; m=0; d1=distances[path[m]][i]; d2=distances[path[m+1]][i]; d3=distances[path[m]][path[m+1]]; minCost = ( d1 + d2 ) - d3; for(int l=1;l<k-1;l++) { d1=distances[path[l]][i]; d2=distances[path[l+1]][i]; d3=distances[path[l]][path[l+1]]; cost=(d1+d2)-d3; if(cost<minCost) { minCost=cost; m=l; } } std::vector<int>::iterator myit = path.begin(); myit+=(m+1); //if(m == 0) //{ // cout << "\nWHOA!\n"; //} path.emplace(myit,i); k++; } } //for(int x=0;x<k;x++) // cout << path[x] << " "; //cout << endl; fwd.push_back(0); bkd.push_back(0); std::vector<int>::iterator i1,i2; for(int i=1;i<count;i++) { //cout << "Inside for"; //fwd[i]=0; //bkd[i]=0; /*std::vector<int>::iterator i3,i4; i3 = fwd.emplace(i3,0); i4 = bkd.emplace(i4,0);*/ fwd.push_back(0); bkd.push_back(0); } i1 = fwd.begin(); i2 = bkd.begin(); for(int i=1;i<count;i++) { fwd[path[i]] = path[i-1]; //////i-1 doesnot exist for 0 bkd[path[i-1]] = path[i]; } }
void good_emplace(std::vector<int> &v, int n) { v.emplace(v.cbegin(), n); // no-warning }
void bad_emplace(std::vector<int> &v1, std::vector<int> &v2, int n) { v2.emplace(v1.cbegin(), n); // expected-warning{{Container accessed using foreign iterator argument}} }