static double test_clear()
{
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();
set.clear();
Generator::generate(data, Count);
for(typename std::vector<T>::const_iterator iter = data.begin();
iter != data.end();
++iter)
{
set.insert(*iter);
}
timer.start();
set.clear();
total_nanos += timer.elapsed().wall;
}
return (unsigned)(total_nanos / (Iterations * Count));
}
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;
}
static inline void removeOutputs()
{
std::lock_guard<std::mutex> lock(sOutputsMutex);
for (Set<LogOutput*>::const_iterator it = sOutputs.begin(); it != sOutputs.end(); ++it)
delete *it;
sOutputs.clear();
}
void initMesh(int nc, int p){
graph.clear();
set.clear();
initial.clear();
constraint.clear();
numCir = nc;
poly = p;
Circle cir = CXY(1);
for (int i = 0; i < numCir; ++i){
VT radius = 1 + 2.0 * (float)i/numCir;
Circle tcir = cir.dilate( log( radius ) );
for (int j = 0; j < poly; ++j ){
VT theta = TWOPI * j / poly;
theta += (rtheta * i * PI/poly);
Point p = Round::pnt_cir(tcir, theta );
set.add( p );
}
}
bool bSwitch = false;
for (int j = 0; j < poly; ++j){
int a = j;
int b = ( j < poly - 1 ) ? j + 1 : 0;
int c = j + poly;
//cout << a << " " << b << " " << c << endl;
initial.add( Rigid2( set[c], set[a], set[b], bSwitch ) );
bSwitch = !bSwitch;
}
bSwitch = false;
for (int i = 1; i < numCir-1; ++i){
for (int j = 0; j < poly; ++j ){
int a = i * poly + j;
int b = a + poly;
int c = j < poly -1 ? a + 1 : i * poly;
int d = j < poly -1 ? a - poly + 1 : (i-1)*poly;
constraint.add( Rigid3( set[b], set[a], set[d], set[c], bSwitch ) );
bSwitch = !bSwitch;
}
}
}
void WatcherThread::clear()
{
MutexLocker locker(&mutex);
flags |= Clear;
paths.clear();
CFRunLoopSourceSignal(source);
CFRunLoopWakeUp(loop);
}
void assign(const Impl* impl)
{
set_.clear();
const size_t count= impl->set_.size();
for (size_t i= 0; i < count; ++i)
add_tag(impl->set_[i]);
}
void WatcherData::clear()
{
std::lock_guard<std::mutex> lock(mutex);
flags |= Clear;
paths.clear();
CFRunLoopSourceSignal(source);
CFRunLoopWakeUp(loop);
}
void Config::set(Set &a, const Set &b, bool merge) {
if(!merge) {
a.clear();
a = b;
return;
}
for(Set::const_iterator i = b.begin(); i != b.end(); ++i) {
a.insert(*i);
}
}
void UndoManager::CalculateSpaceUsage()
{
TIMER_START( "CalculateSpaceUsage", space_calc );
TrackListOfKindIterator iter(Track::Wave);
space.Clear();
space.Add(0, stack.GetCount());
Set s1, s2;
Set *prev = &s1;
Set *cur = &s2;
for (size_t i = 0, cnt = stack.GetCount(); i < cnt; i++)
{
// Swap map pointers
std::swap(cur, prev);
// And clean out the NEW current map
cur->clear();
// Scan all tracks at current level
WaveTrack *wt = (WaveTrack *) iter.First(stack[i]->tracks);
while (wt)
{
// Scan all clips within current track
WaveClipList::compatibility_iterator it = wt->GetClipIterator();
while (it)
{
// Scan all blockfiles within current clip
BlockArray *blocks = it->GetData()->GetSequenceBlockArray();
for (size_t b = 0, cnt = blocks->size(); b < cnt; b++)
{
BlockFile *file = (*blocks)[b].f;
// Accumulate space used by the file if the file didn't exist
// in the previous level
if (prev->count(file) == 0 && cur->count(file) == 0)
{
space[i] += file->GetSpaceUsage().GetValue();
}
// Add file to current set
cur->insert(file);
}
it = it->GetNext();
}
wt = (WaveTrack *) iter.Next();
}
}
TIMER_STOP( space_calc );
}
NodePath Node::get_path_to(const Node *p_node) const {
ERR_FAIL_NULL_V(p_node,NodePath());
if (this==p_node)
return NodePath(".");
Set<const Node*> visited;
const Node *n=this;
while(n) {
visited.insert(n);
n=n->data.parent;
}
const Node *common_parent=p_node;
while(common_parent) {
if (visited.has(common_parent))
break;
common_parent=common_parent->data.parent;
}
ERR_FAIL_COND_V(!common_parent,NodePath()); //nodes not in the same tree
visited.clear();
Vector<StringName> path;
n=p_node;
while(n!=common_parent) {
path.push_back( n->get_name() );
n=n->data.parent;
}
n=this;
StringName up=String("..");
while(n!=common_parent) {
path.push_back( up );
n=n->data.parent;
}
path.invert();
return NodePath(path,false);
}
void BVH::trace(RayBuffer& rays, RayStats* stats) const
{
for(S32 i=0;i<rays.getSize();i++)
{
Ray ray = rays.getRayForSlot(i); // takes a local copy
RayResult& result = rays.getMutableResultForSlot(i);
result.clear();
currentTreelet = -2;
uniqueTreelets.clear();
if(stats)
{
stats->platform = m_platform;
stats->numRays++;
}
traceRecursive(m_root, ray,result,rays.getNeedClosestHit(), stats);
}
}
void TestTools::set_reserve()
{
Set<int> set;
int n = set.capacity();
QVERIFY(n == 0);
set.reserve(1000);
QVERIFY(set.capacity() >= 1000);
for (int i = 0; i < 500; ++i)
set.insert(i);
QVERIFY(set.capacity() >= 1000);
for (int j = 0; j < 500; ++j)
set.remove(j);
QVERIFY(set.capacity() >= 1000);
set.clear();
QVERIFY(set.capacity() == 0);
}
static double test_find_failure()
{
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;
int found = 0;
for(unsigned i = 0; i != Iterations; ++i)
{
data.clear();
set.clear();
Generator::generate(data, Count);
for(typename std::vector<T>::const_iterator iter = data.begin();
iter != data.end();
++iter)
{
set.insert(*iter);
}
data.clear();
Generator::generate(data, Count);
timer.start();
for(typename std::vector<T>::const_iterator iter = data.begin();
iter != data.end();
++iter)
{
if (set.find(*iter) != set.end())
++found;
}
total_nanos += timer.elapsed().wall;
}
if (found == 123) // never
std::cout << "yeah right\n";
return (unsigned)(total_nanos / (Iterations * Count));
}
void init_set() {
S.clear();
rec2(0, 0, 0);
}
void cleanupLogging()
{
std::lock_guard<std::mutex> lock(sOutputsMutex);
sOutputs.clear();
}
int main()
{
Set<nodeT *> graph;
Map<nodeT *> graphMap;
InitGraphics();
SetWindowTitle("Pathfinder");
string backgroundFile;
bool timeToQuit = false;
cout << "This masterful piece of work is a graph extravaganza!" << endl;
while (true) {
cout << "Your options are:" << endl;
cout << "(1) Choose a new graph data file" << endl;
cout << "(2) Find shortest path using Dijkstra's algorithm" << endl;
cout << "(3) Compute the minimal spanning tree using Kruskal's algorithm" << endl;
cout << "(4) Determine if the graph has cycles" << endl;
cout << "(5) Quit" << endl;
cout << "Enter choice: ";
int choice = GetInteger();
string datafile;
void UpdateDisplay();
switch (choice) {
case 1:
cout << "Enter the name of the data file: ";
datafile = GetLine();
//datafile = "Small.txt";
//datafile = "USA.txt";
//datafile = "Stanford.txt";
graph.clear();
graphMap.clear();
backgroundFile = ReadGraph(graph, graphMap, datafile);
break;
case 2:
if (backgroundFile == "") {
cout << "No file is specified" << endl;
}
else {
UpdateDisplay();
MovePen(0,0);
DrawNamedPicture(backgroundFile);
DrawNodesAndArcs(graph);
cout << "(2) Finding shortest path using Dijkstra's algorithm" << endl;
HandleShortestPath(graph);
}
break;
case 3:
if (backgroundFile == "") {
cout << "No file is specified" << endl;
}
else {
cout << "(3) Computing the minimal spanning tree using Kruskal's algorithm" << endl;
UpdateDisplay();
MovePen(0,0);
DrawNamedPicture(backgroundFile);
//DrawNodesAndArcs(graph);
minimumSpanningTree(graph, graphMap);
}
break;
case 4:
if (backgroundFile == "") {
cout << "No file is specified" << endl;
}
else {
graphT graph2;
graph2.allNodes = graph;
cout << "(4) Determining if the graph has cycles" << endl;
if (IsCyclicGraph(graph2))
cout << "Yes, it is cyclic" << endl;
else
cout << "No, it is not cyclic" << endl;
}
break;
case 5:
cout << "Thanks for using Pathfinder. Bye!" << endl;
timeToQuit = true;
break;
default:
cout << "Invalid choice" << endl;
break;
}
if (timeToQuit) break;
}
return (0);
}
void ServerSocket::getLocalAddresses(Set<Address> &set) const
{
set.clear();
Address bindAddr = getBindAddress();
#ifdef NO_IFADDRS
// Retrieve hostname
char hostname[HOST_NAME_MAX];
if(gethostname(hostname,HOST_NAME_MAX))
throw NetException("Cannot retrieve hostname");
// Resolve hostname
addrinfo *aiList = NULL;
addrinfo aiHints;
std::memset(&aiHints, 0, sizeof(aiHints));
aiHints.ai_family = AF_UNSPEC;
aiHints.ai_socktype = SOCK_STREAM;
aiHints.ai_protocol = 0;
aiHints.ai_flags = 0;
String service;
service << mPort;
if(getaddrinfo(hostname, service.c_str(), &aiHints, &aiList) != 0)
{
LogDebug("ServerSocket", "Local hostname is not resolvable");
if(getaddrinfo("localhost", service.c_str(), &aiHints, &aiList) != 0)
{
set.insert(bindAddr);
return;
}
}
addrinfo *ai = aiList;
while(ai)
{
if(ai->ai_family == AF_INET || ai->ai_family == AF_INET6)
{
Address addr(ai->ai_addr,ai->ai_addrlen);
String host = addr.host();
if(ai->ai_addr->sa_family != AF_INET6 || host.substr(0,4) != "fe80")
{
if(addr == bindAddr)
{
set.clear();
set.insert(addr);
break;
}
set.insert(addr);
}
}
ai = ai->ai_next;
}
freeaddrinfo(aiList);
#else
ifaddrs *ifas = NULL;
if(getifaddrs(&ifas) < 0)
throw NetException("Unable to list network interfaces");
ifaddrs *ifa = ifas;
while(ifa)
{
sockaddr *sa = ifa->ifa_addr;
if(sa)
{
socklen_t len = 0;
switch(sa->sa_family)
{
case AF_INET: len = sizeof(sockaddr_in); break;
case AF_INET6: len = sizeof(sockaddr_in6); break;
}
if(len)
{
Address addr(sa, len);
String host = addr.host();
if(host.substr(0,4) != "fe80")
{
addr.set(host, mPort);
if(addr == bindAddr)
{
set.clear();
set.insert(addr);
break;
}
set.insert(addr);
}
}
}
ifa = ifa->ifa_next;
}
freeifaddrs(ifas);
#endif
}
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");
}
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;
}
void WatcherData::run()
{
for (;;) {
if (hasChanged()) {
slices.clear();
updatePaths();
auto where = changes.begin();
const auto end = changes.end();
while (where != end) {
auto to = where + MAXIMUM_WAIT_OBJECTS - 1; // - 1 since we want a wakeup event as well
if (to > end)
to = end;
slices.push_back(std::unique_ptr<WatcherSlice>(new WatcherSlice(where, to,
std::bind(&WatcherData::updated, this,
std::placeholders::_1),
handleToPath)));
where = to;
}
}
const DWORD res = WaitForSingleObject(wakeupHandle, INFINITE);
if (res == WAIT_FAILED) {
fprintf(stderr, "Wait failed in WatcherData::run() %lu\n",
static_cast<unsigned long>(GetLastError()));
break;
}
assert(res - WAIT_OBJECT_0 == 0);
// woken up
//printf("!!!Woken up\n");
std::lock_guard<std::mutex> changeLocker(changeMutex);
if (stopped) {
//printf("!!!! Stopped?\n");
break;
}
std::lock_guard<std::mutex> updateLocker(updateMutex);
if (!changedPaths.empty()) {
for (const Path& p : changedPaths) {
//printf("path was modified... %s\n", p.constData());
PathData& data = pathData[p];
p.visit([&data](const Path &pp) {
if (pp.isFile()) {
//printf("updateDir %s\n", p.constData());
const auto modif = data.modified.find(pp);
if (modif == data.modified.end()) {
//printf("added\n");
// new file
data.added.insert(pp);
return Path::Continue;
}
data.seen.insert(pp);
// possibly modified file
if (pp.lastModifiedMs() != modif->second) {
//printf("modified\n");
// really modified
data.changed.insert(pp);
}
return Path::Continue;
}
return Path::Recurse;
});
Set<Path> removed;
// calculate the removed files (modified - seen)
const auto send = data.seen.end();
for (const std::pair<Path, uint64_t>& mod : data.modified) {
if (data.seen.find(mod.first) == send) {
removed.insert(mod.first);
} else {
// update to our new time
data.modified[mod.first] = mod.first.lastModifiedMs();
}
}
// update the modified structure
for (const Path& ap : data.added) {
data.modified[ap] = ap.lastModifiedMs();
}
for (const Path& rp : removed) {
data.modified.erase(rp);
}
//printf("hei, removed %u, added %u, changed %u\n", removed.size(), data.added.size(), data.changed.size());
if (!removed.empty())
EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsRemoved, watcher, std::placeholders::_1), std::move(removed));
if (!data.added.empty())
EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsAdded, watcher, std::placeholders::_1), std::move(data.added));
if (!data.changed.empty())
EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsModified, watcher, std::placeholders::_1), std::move(data.changed));
data.added.clear();
data.changed.clear();
data.seen.clear();
}
changedPaths.clear();
}
}
slices.clear();
}
