void subtract(const Set& s1, const Set& s2, Set& result) { Set A = s1; Set B = s2; Set C; result = C; //clear the contents of result by setting it equal to empty Set C for (int a = 0; a < B.size(); a++) { ItemType value; B.get(a, value); if (A.contains(value)) { A.erase(value); //if A contains a value that is also in B, delete it from A } } for (int d = 0; d < A.size(); d++) { ItemType value; A.get(d, value); result.insert(value); //insert these into result, which now only contains values from A and not B } }
bool Config::loadSetting(const std::string &line, const std::string &name, Set &var) const { size_t i = isSetting(line, name, "="); if(i != std::string::npos) { var.clear(); var.insert( trim(line.substr(i)) ); return true; } i = isSetting(line, name, "+="); if(i != std::string::npos) { var.insert( trim(line.substr(i)) ); return true; } i = isSetting(line, name, "-="); if(i != std::string::npos) { Set::iterator a = var.find( trim(line.substr(i)) ); if(a != var.end()) { var.erase(a); } return true; } return false; }
inline int lis () { Set s; pair <Iterator, bool> p_it; Iterator &it = p_it.first; int n = seq.size(); Pair p; int &i = p.second; for( i = 0; i < n; ++i ) { p.first = seq[i].first; p_it = s.insert( p ); if( it != s.begin() ) { Iterator it_aux = it; --it_aux; seq[i].second = (*it_aux).second; } if(p_it.second && ++it != s.end() ) s.erase( it ); } p = *( s.rbegin() ); do { p = seq[i]; l.push_front (p.first); } while (i != NP); return s.size(); }
static double test_mix() { static unsigned const Iterations = 10000; static unsigned const Count = 1000; Set set; initialize<Set>(set); boost::timer::cpu_timer timer; double total_nanos = 0; std::vector<T> data; for(unsigned i = 0; i != Iterations; ++i) { data.clear(); Generator::generate(data, Count); timer.start(); for(typename std::vector<T>::const_iterator iter = data.begin(); iter != data.end(); ++iter) { set.insert(*iter); } for(typename std::vector<T>::const_iterator iter = data.begin(); iter != data.end(); ++iter) { set.erase(*iter); } total_nanos += timer.elapsed().wall; } return (unsigned)(total_nanos / (Iterations * Count)); }
// ============================================================================ // update the content of Data-On-Demand actions // ============================================================================ StatusCode DataOnDemandSvc::update () { if ( !m_updateRequired ) { return StatusCode::SUCCESS ; } /// convert obsolete "Nodes" into new "NodeMap" StatusCode sc = setupNodeHandlers() ; // convert "Nodes" new "NodeMap" if ( sc.isFailure() ) { stream() << MSG::ERROR << "Failed to setup old \"Nodes\"" << endmsg ; return sc ; } /// convert obsolete "Algorithms" into new "AlgMap" sc = setupAlgHandlers() ; // convert "Algorithms" into "AlgMap" if ( sc.isFailure() ) { stream() << MSG::ERROR << "Failed to setup old \"Algorithms\"" << endmsg ; return sc ; } /// add the default prefix add_prefix ( m_algMap , m_prefix ) ; /// add the default prefix add_prefix ( m_nodeMap , m_prefix ) ; /// get all directories typedef std::set<std::string> Set ; Set dirs ; if ( m_partialPath ){ get_dirs ( m_algMap , dirs ) ; } if ( m_partialPath ){ get_dirs ( m_nodeMap , dirs ) ; } // Set::iterator _e = dirs.find("/Event") ; if ( dirs.end() != _e ) { dirs.erase( _e ) ; } // add all directories as nodes for ( Set::const_iterator dir = dirs.begin() ; dirs.end() != dir ; ++dir ) { if ( m_algMap .end () != m_algMap .find ( *dir ) ) { continue ; } if ( m_nodeMap .end () != m_nodeMap .find ( *dir ) ) { continue ; } m_nodeMap [*dir] = "DataObject" ; } // m_algs .clear () ; m_nodes .clear () ; // /// setup algorithms for ( Map::const_iterator ialg = m_algMap.begin() ; m_algMap.end() != ialg ; ++ialg ) { if (i_setAlgHandler(ialg->first, ialg->second).isFailure()) return StatusCode::FAILURE; } /// setup nodes for ( Map::const_iterator inode = m_nodeMap.begin() ; m_nodeMap.end() != inode ; ++inode ) { i_setNodeHandler(inode->first, inode->second); } /// m_updateRequired = false ; // return StatusCode::SUCCESS ; }
void testBookSet () { Currency const c1 (1); Account const i1 (1); Currency const c2 (2); Account const i2 (2); IssueRef const a1 (c1, i1); IssueRef const a2 (c2, i2); BookRef const b1 (a1, a2); BookRef const b2 (a2, a1); { Set c; c.insert (b1); if (! expect (c.size () == 1)) return; c.insert (b2); if (! expect (c.size () == 2)) return; if (! expect (c.erase (Book (a1, a1)) == 0)) return; if (! expect (c.erase (Book (a1, a2)) == 1)) return; if (! expect (c.erase (Book (a2, a1)) == 1)) return; if (! expect (c.empty ())) return; } { Set c; c.insert (b1); if (! expect (c.size () == 1)) return; c.insert (b2); if (! expect (c.size () == 2)) return; if (! expect (c.erase (BookRef (a1, a1)) == 0)) return; if (! expect (c.erase (BookRef (a1, a2)) == 1)) return; if (! expect (c.erase (BookRef (a2, a1)) == 1)) return; if (! expect (c.empty ())) return; #if STL_SET_HAS_EMPLACE c.emplace (a1, a2); if (! expect (c.size() == 1)) return; c.emplace (a2, a1); if (! expect (c.size() == 2)) return; #endif } }
void cleanupLogging() { Set<LogOutput*>::const_iterator it = sOutputs.begin(); while (it != sOutputs.end()) { LogOutput *out = *it; sOutputs.erase(it++); delete out; } }
/** * Make a range de-allocated. */ void unsetAllocated(size_t off) { SetIterator it = set_.lower_bound({off, 0}); assert(it != set_.end()); assert(it->first == off); size_t size = it->second; set_.erase(it); allocated_ -= size; if (set_.empty()) { maxItemSize_ = 0; } }
void subtract(const Set& s1, const Set& s2, Set& result) { result=s1; //assignment operator creates new copy of s1 int loops=s2.size(); //want to check every element of s2 for (int i=1;i<=loops;i++) { ItemType value; s2.get(i, value); result.erase(value);//won't do anything if value in s2 is not in s1 } }
static void testSet() { mDestructions = mConstructions = mCopyConstructions = mAssigns = 0; { Set<Counter> set; T(0,0,0,0); set.insert(Counter(1)); T(2,3,2,0); set.erase(Counter(1)); T(4,4,2,0); } T(4,4,2,0); }
bool WatcherData::unwatch(const Path& path) { std::lock_guard<std::mutex> lock(mutex); auto p = paths.find(path); if (p == paths.end()) return false; paths.erase(p); CFRunLoopSourceSignal(source); CFRunLoopWakeUp(loop); return true; }
void SerialPartitionerBase::getNeighbors(const Mesh& mesh, Array<Array<int> >& neighbors, int& nEdges) const { int dim = mesh.spatialDim(); int nElems = mesh.numCells(dim); int nVerts = mesh.numCells(0); neighbors.resize(nElems); nEdges = 0; elemVerts_.resize(nElems); vertElems_.resize(nVerts); for (int c=0; c<nElems; c++) { Array<int> facetLID; Array<int> facetDir; mesh.getFacetArray(dim, c, 0, facetLID, facetDir); elemVerts_[c] = arrayToSet(facetLID); } for (int v=0; v<nVerts; v++) { Array<int> cofacetLID; mesh.getCofacets(0, v, dim, cofacetLID); vertElems_[v] = arrayToSet(cofacetLID); } for (int i=0; i<nElems; i++) { Set<int> allNbors; const Set<int>& ev = elemVerts_[i]; for (Set<int>::const_iterator v=ev.begin(); v!=ev.end(); v++) { allNbors = allNbors.setUnion(vertElems_[*v]); } allNbors.erase(i); Array<int> fullNbors; for (Set<int>::const_iterator j=allNbors.begin(); j!=allNbors.end(); j++) { Set<int> numCommonNodes = elemVerts_[i].intersection(elemVerts_[*j]); if ((int) numCommonNodes.size() == dim) fullNbors.append(*j); } nEdges += fullNbors.size(); neighbors[i] = fullNbors; } nEdges = nEdges/2; }
int main() { Set ss; ss.insert("focaccia"); assert(!ss.contains("")); ss.insert("tortilla"); ss.insert(""); ss.insert("lavash"); assert(ss.contains("")); ss.erase("focaccia"); assert(ss.size() == 3); assert(ss.contains("lavash")); assert(ss.contains("tortilla")); assert(ss.contains("")); }
Set<T> Set<T>::subtract(Set<T> other) const { if(setType == INFINITE_SET) return Set<T> s(other); if(other.setType == INFINITE_SET) return Set<T> s; Set<T> s = *this; for(T t : other) { if(contains(t)) s.erase(t); } return s; }
Provenance::Set* Provenance::descendants(const Set& roots) { Set open = roots; Set* closed = new Set(); while (!open.empty()) { const Provenance* n = *(open.begin()); const Set& c = n->children(); for (const Provenance* s : c) { // If s isn't in closed set, put it in open if (closed->find(s) == closed->end()) open.insert(s); } open.erase(n); closed->insert(n); } return closed; }
int main() { Set<int> a; ///set<int> a; a.insert(3); a.insert(4); a.insert(5); a.insert(4); a.insert(3); a.insert(2); a.insert(6); printSet(a); a.erase( a.begin() ); printSet(a); return 0; }
int main () { // Create a set and insert 10 element into it. Set sd; for (Set::value_type i = 0; i < 10; ++i) sd.insert (i); // Print out the set. std::cout << sd << "\n\n"; // Erase half of the elements in the set. Set::iterator sdi = sd.begin(); std::advance (sdi, sd.size () / 2); sd.erase (sd.begin(), sdi); // Print it out again. std::cout << sd << "\n\n"; // Make another set and an empty result set. Set sd2, sdResult; for (Set::value_type j = 1; j < 9; ++j) sd2.insert (j + 5); std::cout << sd2 << std::endl; // Try a couple of set algorithms. std::set_union (sd.begin (),sd.end (),sd2.begin (), sd2.end (), std::inserter (sdResult, sdResult.begin ())); std::cout << "Union:\n" << sdResult << '\n'; sdResult.erase (sdResult.begin (),sdResult.end ()); std::set_intersection (sd.begin (), sd.end (), sd2.begin (), sd2.end (), std::inserter (sdResult, sdResult.begin ())); std::cout << "Intersection:\n" << sdResult << '\n'; return 0; }
Provenance::Set* Provenance::ancestors(const Set& roots) { Set open = roots; Set* closed = new Set(); while (!open.empty()) { const Provenance* n = *(open.begin()); std::pair<CommandChronicle::ParentVector::const_iterator, CommandChronicle::ParentVector::const_iterator> pr = n->parents(); for (CommandChronicle::ParentVector::const_iterator it = pr.first; it != pr.second; ++it) { const Provenance* prov = *it; if (closed->count(prov) == 0) open.insert(prov); } open.erase(n); closed->insert(n); } return closed; }
void test() { Set<int> si; Set<string> ss; assert(si.empty()); assert(ss.size() == 0); assert(si.insert(10)); assert(ss.insert("hello")); assert(si.contains(10)); assert(si.erase(10)); string s; assert(ss.get(0, s) && s == "hello"); Set<string> ss2(ss); ss.swap(ss2); ss = ss2; unite(si,si,si); unite(ss,ss2,ss); subtract(si,si,si); subtract(ss,ss2,ss); cout << "Passed all tests" << endl; }
void EditorExportPlatform::_edit_files_with_filter(DirAccess *da, const Vector<String> &p_filters, Set<String> &r_list, bool exclude) { da->list_dir_begin(); String cur_dir = da->get_current_dir().replace("\\", "/"); if (!cur_dir.ends_with("/")) cur_dir += "/"; String cur_dir_no_prefix = cur_dir.replace("res://", ""); Vector<String> dirs; String f; while ((f = da->get_next()) != "") { if (da->current_is_dir()) dirs.push_back(f); else { String fullpath = cur_dir + f; // Test also against path without res:// so that filters like `file.txt` can work. String fullpath_no_prefix = cur_dir_no_prefix + f; for (int i = 0; i < p_filters.size(); ++i) { if (fullpath.matchn(p_filters[i]) || fullpath_no_prefix.matchn(p_filters[i])) { if (!exclude) { r_list.insert(fullpath); } else { r_list.erase(fullpath); } } } } } da->list_dir_end(); for (int i = 0; i < dirs.size(); ++i) { String dir = dirs[i]; if (dir.begins_with(".")) continue; da->change_dir(dir); _edit_files_with_filter(da, p_filters, r_list, exclude); da->change_dir(".."); } }
void unite(const Set& s1, const Set& s2, Set& result) { Set A = s1; Set B = s2; result = A; for (int a = 0; a < A.size(); a++) { ItemType value; A.get(a, value); if (B.contains(value)) { B.erase(value); //if set B contains a value in A, then erase it from B } } for (int c = 0; c < B.size(); c++) { ItemType value; B.get(c, value); result.insert(value); //now insert every value in B into result (these don't contain any DUPLICATES from A) } }
int main(){ Set t; assert( t.size( ) == 0 ); assert( t.insert("hello") == true ); assert( t.size( ) == 1 ); assert( t.insert("how") == true ); assert( t.size( ) == 2 ); assert( t.insert("are") == true ); assert( t.size( ) == 3 ); assert( t.insert("you?") == true ); assert( t.size( ) == 4 ); assert( t.insert("all") == true ); assert( t.size( ) == 5 ); assert( t.insert("great!") == true ); assert( t.size( ) == 6 ); assert( t.insert("jello") == true ); assert( t.size( ) == 7 ); assert( t.insert("apples") == true ); assert( t.size( ) == 8 ); assert( t.insert("zoo") == true ); assert( t.size( ) == 9 ); assert( t.insert("zoo") == false ); assert( t.size( ) == 9 ); assert( t.insert("zebra") == true ); assert( t.size( ) == 10 ); assert( t.insert("zap") == true ); assert( t.size( ) == 11 ); assert( t.insert("aladdin") == true ); assert( t.size( ) == 12 ); assert( t.find("hello") == true ); assert( t.find("how") == true ); assert( t.find("are") == true ); assert( t.find("you") == false ); assert( t.find("you?") == true ); assert( t.find("all") == true ); assert( t.find("great") == false ); assert( t.find("great!") == true ); assert( t.find("jello") == true ); assert( t.find("apples!") == false ); assert( t.find("apples") == true ); assert( t.find("zoo") == true ); assert( t.find("zooz") == false ); assert( t.find("zap") == true ); assert( t.find("zebra") == true ); assert( t.find("aladdin") == true ); cout << t; t.erase( "zoo" ); t.erase( "hello" ); cout << t; Set p = t; //assert( t.size( ) == 9 ); assert( (p==t) == true ); assert( (p!=t) == false ); p.insert( "gremlin" ); assert( (p==t) == false ); assert( (p!=t) == true ); assert( (p>=t) == true ); assert( (t>=p) == false ); assert( (p<=t) == false ); assert( (t<=p) == true ); p.erase( "how" ); assert( (p>=t) == false ); cout << p << endl; Set::Iterator i; for( i = p.begin( ); i != p.end( ); i++ ) { cout << *i << " "; } cout << "\ntesting complete" << endl; }
int main() { //General mutators tests Set s1; s1.insert("focaccia"); assert(!s1.contains("")); s1.insert("tortilla"); s1.insert(""); s1.insert("lavash"); assert(s1.contains("")); s1.erase("focaccia"); assert(s1.size() == 3 && s1.contains("lavash") && s1.contains("tortilla") && s1.contains("")); Set setex; assert(setex.empty()); setex.insert("first"); assert(setex.size() == 1 && setex.contains("first") && !setex.contains("second")); setex.erase("first"); assert(setex.size() == 0); // //swap test Set ss1; ss1.insert("injera"); Set ss2; ss2.insert("matzo"); ss2.insert("dosa"); ss1.swap(ss2); assert(ss1.size() == 2 && ss1.contains("matzo") && ss1.contains("dosa") && ss2.size() == 1 && ss2.contains("injera")); //end swap test //get tests Set ss; ss.insert("A"); ss.insert("C"); ss.insert("A"); ss.insert("B"); string all; for (int k = 0; k < ss.size(); k++) { string x; ss.get(k, x); all += x; } Set SS; SS.insert("pita"); SS.insert("roti"); string test; assert(SS.get(1, test) && (test == "roti" || test == "pita")); string s2; assert(SS.get(1, s2) && s2 == test); Set s; assert(s.empty()); string x = "arepa"; assert(!s.get(42, x) && x == "arepa"); // x unchanged by get failure s.insert("chapati"); assert(s.size() == 1); assert(s.get(0, x) && x == "chapati"); //end get tests cout << "Passed all tests" << endl; }
bool EditorExportPlatformAndroid::_set(const StringName& p_name, const Variant& p_value) { String n=p_name; if (n=="one_click_deploy/clear_previous_install") remove_prev=p_value; else if (n=="custom_package/debug") custom_debug_package=p_value; else if (n=="custom_package/release") custom_release_package=p_value; else if (n=="version/code") version_code=p_value; else if (n=="version/name") version_name=p_value; else if (n=="command_line/extra_args") cmdline=p_value; else if (n=="package/unique_name") package=p_value; else if (n=="package/name") name=p_value; else if (n=="package/icon") icon=p_value; else if (n=="package/signed") _signed=p_value; else if (n=="architecture/arm") export_arm=p_value; else if (n=="architecture/x86") export_x86=p_value; else if (n=="screen/use_32_bits_view") use_32_fb=p_value; else if (n=="screen/immersive_mode") immersive=p_value; else if (n=="screen/orientation") orientation=p_value; else if (n=="screen/support_small") screen_support[SCREEN_SMALL]=p_value; else if (n=="screen/support_normal") screen_support[SCREEN_NORMAL]=p_value; else if (n=="screen/support_large") screen_support[SCREEN_LARGE]=p_value; else if (n=="screen/support_xlarge") screen_support[SCREEN_XLARGE]=p_value; else if (n=="keystore/release") release_keystore=p_value; else if (n=="keystore/release_user") release_username=p_value; else if (n=="keystore/release_password") release_password=p_value; else if (n=="apk_expansion/enable") apk_expansion=p_value; else if (n=="apk_expansion/SALT") apk_expansion_salt=p_value; else if (n=="apk_expansion/public_key") apk_expansion_pkey=p_value; else if (n.begins_with("permissions/")) { String what = n.get_slicec('/',1).to_upper(); bool state = p_value; if (state) perms.insert(what); else perms.erase(what); } else if (n.begins_with("user_permissions/")) { int which = n.get_slicec('/',1).to_int(); ERR_FAIL_INDEX_V(which,MAX_USER_PERMISSIONS,false); user_perms[which]=p_value; } else return false; return true; }
Array<Mesh> SerialPartitionerBase::makeMeshParts(const Mesh& mesh, int np, Array<Sundance::Map<int, int> >& oldElemLIDToNewLIDMaps, Array<Sundance::Map<int, int> >& oldVertLIDToNewLIDMaps) const { int dim = mesh.spatialDim(); Array<int> elemAssignments; Array<int> nodeAssignments; Array<int> nodeOwnerElems; Array<int> nodesPerProc; getAssignments(mesh, np, elemAssignments); getNodeAssignments(np, elemAssignments, nodeAssignments, nodeOwnerElems, nodesPerProc); Array<Array<int> > offProcNodes(np); Array<Array<int> > offProcElems(np); Array<Set<int> > offProcNodeSet(np); Array<Set<int> > offProcElemSet(np); Array<Array<int> > procNodes(np); Array<Array<int> > procElems(np); for (int p=0; p<np; p++) { getOffProcData(p, elemAssignments, nodeAssignments, offProcNodeSet[p], offProcElemSet[p]); offProcNodes[p] = offProcNodeSet[p].elements(); offProcElems[p] = offProcElemSet[p].elements(); procElems[p].reserve(elemAssignments.size()/np); procNodes[p].reserve(nodeAssignments.size()/np); } Array<int> remappedElems; Array<int> remappedNodes; remapEntities(elemAssignments, np, remappedElems); remapEntities(nodeAssignments, np, remappedNodes); for (int e=0; e<elemAssignments.size(); e++) { procElems[elemAssignments[e]].append(e); } for (int n=0; n<nodeAssignments.size(); n++) { procNodes[nodeAssignments[n]].append(n); } /* Now we make NP submeshes */ Array<Mesh> rtn(np); oldVertLIDToNewLIDMaps.resize(np); oldElemLIDToNewLIDMaps.resize(np); for (int p=0; p<np; p++) { Sundance::Map<int, int>& oldVertLIDToNewLIDMap = oldVertLIDToNewLIDMaps[p]; Sundance::Map<int, int>& oldElemLIDToNewLIDMap = oldElemLIDToNewLIDMaps[p]; MeshType type = new BasicSimplicialMeshType(); rtn[p] = type.createEmptyMesh(mesh.spatialDim(), MPIComm::world()); Set<int> unusedVertGID; /* add the on-processor nodes */ for (int n=0; n<procNodes[p].size(); n++) { int oldLID = procNodes[p][n]; int newGID = remappedNodes[oldLID]; unusedVertGID.put(newGID); int newLID = rtn[p].addVertex(newGID, mesh.nodePosition(oldLID), p, 0); oldVertLIDToNewLIDMap.put(oldLID, newLID); } /* add the off-processor nodes */ for (int n=0; n<offProcNodes[p].size(); n++) { int oldLID = offProcNodes[p][n]; int nodeOwnerProc = nodeAssignments[oldLID]; int newGID = remappedNodes[oldLID]; unusedVertGID.put(newGID); int newLID = rtn[p].addVertex(newGID, mesh.nodePosition(oldLID), nodeOwnerProc, 0); oldVertLIDToNewLIDMap.put(oldLID, newLID); } /* add the on-processor elements */ for (int e=0; e<procElems[p].size(); e++) { int oldLID = procElems[p][e]; int newGID = remappedElems[oldLID]; Array<int> vertGIDs; Array<int> orientations; mesh.getFacetArray(dim, oldLID, 0, vertGIDs, orientations); for (int v=0; v<vertGIDs.size(); v++) { vertGIDs[v] = remappedNodes[vertGIDs[v]]; if (unusedVertGID.contains(vertGIDs[v])) unusedVertGID.erase(newGID); } int newLID = rtn[p].addElement(newGID, vertGIDs, p, 1); oldElemLIDToNewLIDMap.put(oldLID, newLID); } /* add the off-processor elements */ for (int e=0; e<offProcElems[p].size(); e++) { int oldLID = offProcElems[p][e]; int newGID = remappedElems[oldLID]; int elemOwnerProc = elemAssignments[oldLID]; Array<int> vertGIDs; Array<int> orientations; mesh.getFacetArray(dim, oldLID, 0, vertGIDs, orientations); for (int v=0; v<vertGIDs.size(); v++) { vertGIDs[v] = remappedNodes[vertGIDs[v]]; if (unusedVertGID.contains(vertGIDs[v])) unusedVertGID.erase(newGID); } int newLID = rtn[p].addElement(newGID, vertGIDs, elemOwnerProc, 1); oldElemLIDToNewLIDMap.put(oldLID, newLID); // TEST_FOR_EXCEPTION(unusedVertGID.size() != 0, InternalError, // "unused vertices=" << unusedVertGID); } /* Now, propagate the labels of any intermediate-dimension cells * to the submesh */ for (int d=1; d<dim; d++) { Set<int> labels = mesh.getAllLabelsForDimension(d); for (Set<int>::const_iterator i=labels.begin(); i!=labels.end(); i++) { Array<int> labeledCells; int label = *i; if (label == 0) continue; mesh.getLIDsForLabel(d, label, labeledCells); for (int c=0; c<labeledCells.size(); c++) { int lid = labeledCells[c]; Array<int> cofacets; mesh.getCofacets(d, lid, dim, cofacets); for (int n=0; n<cofacets.size(); n++) { int cofLID = cofacets[n]; if (elemAssignments[cofLID]==p || offProcElemSet[p].contains(cofLID)) { /* at this point we need to find the facet index of the side * relative to the new element. */ /* find vertices of old cell */ Array<int> oldVerts; Array<int> newVerts; Array<int> orientation; mesh.getFacetArray(d, lid, 0, oldVerts, orientation); for (int v=0; v<oldVerts.size(); v++) { newVerts.append(remappedNodes[oldVerts[v]]); } /* Put the vertices in a set. This will let us compare to the * vertex sets in the new submesh. */ Set<int> newVertSet = arrayToSet(newVerts); /* Find the cofacet in the new submesh */ int newElemLID = oldElemLIDToNewLIDMap.get(cofLID); /* Get the d-facets of the element in the new submesh */ Array<int> submeshFacets; rtn[p].getFacetArray(dim, newElemLID, d, submeshFacets, orientation); int facetIndex = -1; for (int df=0; df<submeshFacets.size(); df++) { /* Get the vertices of this d-facet */ int facetLID = submeshFacets[df]; Array<int> verts; rtn[p].getFacetArray(d, facetLID, 0, verts, orientation); Array<int> vertGID(verts.size()); for (int v=0; v<verts.size(); v++) { vertGID[v] = rtn[p].mapLIDToGID(0, verts[v]); } Set<int> subVertSet = arrayToSet(vertGID); if (subVertSet==newVertSet) { facetIndex = df; break; } } TEST_FOR_EXCEPTION(facetIndex==-1, InternalError, "couldn't match new " << d << "-cell in submesh to old " << d << "cell. This should never happen"); /* OK, now we have the d-cell's facet index relative to one * of its cofacets existing on the new submesh. We now * find the LID of the d-cell so we can set its label */ int o; // dummy orientation variable; not needed here int newFacetLID = rtn[p].facetLID(dim, newElemLID, d, facetIndex, o); /* Set the label, finally! */ rtn[p].setLabel(d, newFacetLID, label); break; /* no need to continue the loop over cofacets once * we've set the label */ } else { } } } } } } return rtn; }
void setInt() { Set<int> s; //insert assert("Set::insert()", s.insert(2).second); assert("Set::insert()", s.insert(3).second); assert("Set::insert()", s.insert(4).second); assert("Set::size()", s.size() == 3); //dupe insert Pair<Set<int>::Iterator, bool> res = s.insert(2); assert("Set::insert()", !res.second); assert("Set::insert()", res.first != s.end()); assert("Set::insert()", *res.first == 2); //find Set<int>::Iterator itr = s.find(3); assert("Set::find()", itr != s.end()); assert("Set::find()", *itr == 3); //iterate itr = s.begin(); assert("Set::begin()", itr != s.end()); assert("Set::Iterator", *itr == 2); ++itr; assert("Set::Iterator", *itr == 3); ++itr; assert("Set::Iterator", *itr == 4); ++itr; assert("Set::Iterator", itr == s.end()); //iterator --itr; assert("Set::Iterator--", itr != s.end()); itr--; itr++; itr++; assert("Set::Iterator++", itr == s.end()); itr--; assert("Set::Iterator--", itr != s.end()); //const iterator Set<int>::ConstIterator citr = s.find(3); assert("cSet::find()", citr != s.end()); assert("cSet::find()", *citr == 3); citr = s.begin(); assert("cSet::begin()", citr != s.end()); assert("cSet::Iterator", *citr == 2); ++citr; assert("cSet::Iterator", *citr == 3); ++citr; assert("cSet::Iterator", *citr == 4); ++citr; assert("cSet::Iterator", citr == s.end()); --citr; assert("cSet::Iterator--", citr != s.end()); citr--; citr++; citr++; assert("cSet::Iterator++", citr == s.end()); citr--; assert("cSet::Iterator--", citr != s.end()); //erase assert("Set::erase()", s.erase(3)); assert("Set::erase()", s.size() == 2); //copy constuctor Set<int> copy(s); assert("Set::Set(Set)", copy.size() == 2); //clear s.clear(); assert("Set::clear()", s.size() == 0); itr = s.find(4); assert("Set::clear()", itr == s.end()); assert("Set::clear()", s.begin() == s.end()); //assignment operator s = copy; assert("Set::operator=()", s.size() == 2); }
int main() { Set set; UnorderedSet::bucket_type buckets[10]; UnorderedSet unordered_set(UnorderedSet::bucket_traits(buckets, 10)); const char * const expensive_key = "A long string that avoids small string optimization"; Expensive value(expensive_key); if(get_from_set(expensive_key, set)){ return 1; } if(get_from_uset(expensive_key, unordered_set)){ return 1; } if(get_from_set_optimized(expensive_key, set)){ return 1; } if(get_from_uset_optimized(expensive_key, unordered_set)){ return 1; } Set::iterator setit = set.insert(value).first; UnorderedSet::iterator unordered_setit = unordered_set.insert(value).first; if(!get_from_set(expensive_key, set)){ return 1; } if(!get_from_uset(expensive_key, unordered_set)){ return 1; } if(!get_from_set_optimized(expensive_key, set)){ return 1; } if(!get_from_uset_optimized(expensive_key, unordered_set)){ return 1; } set.erase(setit); unordered_set.erase(unordered_setit); if(!insert_to_set(expensive_key, set)){ return 1; } if(!insert_to_uset(expensive_key, unordered_set)){ return 1; } { Expensive *ptr = &*set.begin(); set.clear(); delete ptr; } { Expensive *ptr = &*unordered_set.begin(); unordered_set.clear(); delete ptr; } if(!insert_to_set_optimized(expensive_key, set)){ return 1; } if(!insert_to_uset_optimized(expensive_key, unordered_set)){ return 1; } { Expensive *ptr = &*set.begin(); set.clear(); delete ptr; } { Expensive *ptr = &*unordered_set.begin(); unordered_set.clear(); delete ptr; } setit = set.insert(value).first; unordered_setit = unordered_set.insert(value).first; if(insert_to_set(expensive_key, set)){ return 1; } if(insert_to_uset(expensive_key, unordered_set)){ return 1; } if(insert_to_set_optimized(expensive_key, set)){ return 1; } if(insert_to_uset_optimized(expensive_key, unordered_set)){ return 1; } set.erase(value); unordered_set.erase(value); return 0; }
static void testInsertErase() { Set<int> set; bool inserted = set.insert(0); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a singleton set is not empty"); ASSERT_always_require2(set.size() == 1, "a singleton set has one member"); ASSERT_always_require2(set.hull().size() == 1, "singleton set has a singleton hull"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has not been inserted yet"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(0); // again ASSERT_always_require2(!inserted, "member should have already existed"); ASSERT_always_require2(!set.isEmpty(), "a singleton set is not empty"); ASSERT_always_require2(set.size() == 1, "a singleton set has one member"); ASSERT_always_require2(set.hull().size() == 1, "singleton set has a singleton hull"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has not been inserted yet"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(1); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has two members"); ASSERT_always_require2(set.hull().size() == 2, "hull of set {0,1} is [0..1]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(set.exists(1), "member one has been inserted"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(2); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a three-member set is not empty"); ASSERT_always_require2(set.size() == 3, "a three-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,1,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(set.exists(1), "member one has been inserted"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); bool erased = set.erase(1); ASSERT_always_require2(erased, "member should have been erased"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has been erased"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); erased = set.erase(1); // again ASSERT_always_require2(!erased, "member has already been erased"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has been erased"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); set.clear(); ASSERT_always_require2(set.isEmpty(), "a cleared set is empty"); ASSERT_always_require2(set.size() == 0, "a cleared set has no members"); ASSERT_always_require2(set.hull().isEmpty(), "a cleared set is empty"); ASSERT_always_require2(!set.exists(0), "member zero has been cleared"); ASSERT_always_require2(!set.exists(1), "member one has been cleared"); ASSERT_always_require2(!set.exists(2), "member two has been cleared"); }