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");
}
