int main()
{
int numbers[10] = {1,2,3,4,5,6,7,8,9,0};
Set<int> a;
Set<int> b(a);
Set<int> c(numbers, 10);
b = a;
assert(b==a);
a = b & c;
assert(a.empty());
a = b & 3;
assert(a.empty());
a = 3 & b;
assert(a.empty());
b &= a;
assert(b.empty());
b &= 3;
assert(b.empty());
b = a | c;
assert(b == c);
b = a | 3;
assert(b.size() == 1);
b = 3 | a;
assert(b.size() == 1);
a |= b;
assert(a.size() == 1);
a |= 3;
assert(a.size() == 1 && a.contains(3));
assert(!(a != b));
assert(a< c);
assert(3 < c);
c > a;
c > 3;
a <= c;
c >= a;
a.contains(3);
a.empty();
a.size();
a.insert(99);
cout << a << endl << c;
a.remove(99);
}
bool Store::retrieveValue(const BinaryString &key, Set<BinaryString> &values)
{
// Note: values is not cleared !
const Identifier localNode = Network::Instance->overlay()->localNode();
Database::Statement statement = mDatabase->prepare("SELECT value FROM map WHERE key = ?1");
statement.bind(1, key);
while(statement.step())
{
BinaryString v;
statement.value(0, v);
values.insert(v);
}
statement.finalize();
if(!values.contains(localNode))
{
// Also look for digest in blocks in case map is not up-to-date
statement = mDatabase->prepare("SELECT 1 FROM blocks WHERE digest = ?1 LIMIT 1");
statement.bind(1, key);
if(statement.step())
values.insert(localNode);
statement.finalize();
}
return !values.empty();
}
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
}
}
/**
* 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; }
}
bool Store::getBlockHints(const BinaryString &digest, Set<BinaryString> &result)
{
retrieveValue(Store::Hash(digest), result);
if(result.empty()) return false;
// Add hints of order 2
Set<BinaryString> tmp;
for(const BinaryString &value : result)
retrieveValue(Store::Hash(value), tmp);
result.insertAll(tmp);
return true;
}
//Beware - FindSolution works only for 4x4 game!!!
void Fifteen::FindSolution()
{
CopyTGameArray(GameArray, GameStartArray);
points = 0;
Set* nothing;
Set* closedSet = new Set();
Set* openSet = new Set();
Set* best = NULL;
openSet->add(openSet, 0, GameArray, openSet, nothing);
while (!openSet->empty())
{
openSet->best(openSet, best);
closedSet->add(closedSet, best->G, best->move, best->prev, best);
openSet->remove(openSet, best->move);
CopyTGameArray(GameArray, best->move);
if(best->H < 1)
{
SetSolution(best);
ShowSolution();
closedSet->DeleteAll(closedSet);
openSet->DeleteAll(openSet);
return;
}
int zeroX;
int zeroY;
FindZero(zeroX, zeroY, best->move);
for (int i = 0; i < 4; i++)
{
int dx = (-1) * ((zeroX > 0) && (i == 0)) + ((zeroX < SIZE - 1) && (i == 1));
int dy = (-1) * ((zeroY > 0) && (i == 2)) + ((zeroY < SIZE - 1) && (i == 3));
TGameArray newArray;
CopyTGameArray(newArray, best->move);
newArray[zeroX][zeroY] = best->move[zeroX+dx][zeroY+dy];
newArray[zeroX+dx][zeroY+dy] = 0;
if(!closedSet->isAlready(closedSet, newArray))
{
openSet->add(openSet, best->G + 1, newArray, best, nothing);
}
}
}
}
void index_set::look_for_cse_mismatch() {
collect_type2_common_subexpressions();
Set tmp;
set_difference( type2_cse.begin(), type2_cse.end(),
marked_cse.begin(), marked_cse.end(),
inserter(tmp, tmp.begin()) );
if (!tmp.empty()) {
ostringstream os;
os << "Indices not marked as CSE: ";
copy(tmp.begin(), tmp.end(), ostream_iterator<int>(os, "\t"));
ASSERT2(false, os.str());
}
}
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(void) {
Set<int> a = { 1, 2, 3 };
Set<int> b = { 2, 4, 6 };
print("a: %v", &a);
print("b: %v", &b);
print("a ismember 3: %s", a.ismember(3) ? "OK" : "FAIL");
Set<int> c;
c = a | b;
print("union: %v", &c);
c = a & b;
print("intersection: %v", &c);
c = a - b;
print("difference: %v", &c);
c = a ^ b;
print("symmetric difference: %v", &c);
c = { 1, 2, 3 };
print("eq: %s", (a == c) ? "OK" : "FAIL");
c |= b;
print("lt: %s", (a < c) ? "OK" : "FAIL");
print("le: %s", (a <= c) ? "OK" : "FAIL");
c = { 4, 5, 6 };
print("disjoint: %s", a.isdisjoint(c) ? "OK" : "FAIL");
a.remove(2);
print("a.remove(2): %v", &a);
while(len(b) > 0) {
print("b.pop(): %d", b.pop());
}
del(a);
print("del(a): %v len: %zu", &a, len(a));
print("a.empty(): %s", a.empty() ? "OK" : "FAIL");
print("operator!(): %s", (!a) ? "OK" : "FAIL");
return 0;
}
void index_set::push_back_current() {
Set* tmp = new Set;
for (Map::const_iterator i=current.begin(); i!=current.end(); ++i) {
const int index = i->first;
const int count = i->second;
tmp->insert(index);
push_back_type3_cse(index, count);
}
ASSERT(!tmp->empty());
constraint_index_sets.push_back(tmp);
current.clear();
}
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
Action::ValueDescSkeletonLink::prepare()
{
if (value_desc_list.empty())
throw Error(Error::TYPE_NOTREADY);
clear();
// get bone
ValueNode_Bone::Handle bone_value_node;
if (value_desc.parent_is_value_node())
bone_value_node = ValueNode_Bone::Handle::cast_dynamic(value_desc.get_parent_value_node());
if (!bone_value_node)
throw Error(Error::TYPE_NOTREADY);
// get static list of bones (skeleton layer)
const ValueDesc &parent = value_desc.get_parent_desc();
ValueNode_StaticList::Handle bone_list_value_node;
if (parent.parent_is_value_node())
bone_list_value_node = ValueNode_StaticList::Handle::cast_dynamic(parent.get_parent_value_node());
if (!bone_list_value_node)
throw Error(Error::TYPE_NOTREADY);
// bones list
typedef std::set<ValueNode_Bone::Handle> Set;
ValueBase::List value_bone_list = (*bone_list_value_node)(time).get_list();
Set list;
for(int i = 0; i < bone_list_value_node->link_count(); ++i)
{
ValueNode_Bone::Handle bone_value_node =
ValueNode_Bone::Handle::cast_dynamic(bone_list_value_node->get_link(i));
if (bone_value_node)
list.insert(bone_value_node);
}
if (list.empty())
throw Error(Error::TYPE_NOTREADY);
// process all selected ducks
Set current_list;
for(std::list<ValueDesc>::iterator iter = value_desc_list.begin(); iter != value_desc_list.end(); ++iter)
{
ValueDesc& value_desc(*iter);
// skip region/outline origin
if (value_desc.parent_is_layer()
&& value_desc.get_param_name() == "origin"
&& (value_desc.get_layer()->get_name() == "advanced_outline"
|| value_desc.get_layer()->get_name() == "outline"
|| value_desc.get_layer()->get_name() == "region"))
continue;
// check type
Type &type(value_desc.get_value_type());
if (!ValueNode_BoneLink::check_type(type)
|| !ValueNode_WeightedAverage::check_type(type)
|| !ValueVector::check_type(type) )
continue;
// don't link bones to bones
if (value_desc.parent_is_value_node()
&& ValueNode_Bone::Handle::cast_dynamic(value_desc.get_parent_value_node()) )
continue;
// List of bones influencing current item
current_list.clear();
for(Set::iterator i = list.begin(); i != list.end(); ++i)
if ((*i)->have_influence_on(time, ValueVector::get_vector(value_desc.get_value(time))))
current_list.insert(*i);
if (current_list.empty()) continue;
ValueNode::Handle node;
if (current_list.size() > 1)
{
// make average node
ValueNode_WeightedAverage::Handle average_node = new ValueNode_WeightedAverage(type, get_canvas());
// get type of weighted value
types_namespace::TypeWeightedValueBase *wt = ValueAverage::get_weighted_type_for(type);
assert(wt != NULL);
// add each bone from influence_list to Average convert
for(Set::iterator i = current_list.begin(); i != current_list.end(); ++i)
{
// make bone link
ValueNode_BoneLink::Handle bone_link_node =
ValueNode_BoneLink::create(value_desc.get_value(time));
bone_link_node->set_link("bone", ValueNode_Const::create(ValueBase(*i), get_canvas()));
bone_link_node->set_link("base_value",
ValueNode_Composite::create(
ValueTransformation::back_transform(
bone_link_node->get_bone_transformation(time),
value_desc.get_value(time) )));
// make weighted value
ValueNode_Composite::Handle weighted_node =
ValueNode_Composite::create(wt->create_weighted_value(1, value_desc.get_value(time)), get_canvas());
weighted_node->set_link("value", bone_link_node);
// add
average_node->add(ValueNode::Handle(weighted_node));
}
node = average_node;
}
else
{
// make bone link
ValueNode_BoneLink::Handle bone_link_node =
ValueNode_BoneLink::create(value_desc.get_value(time));
bone_link_node->set_link("bone", ValueNode_Const::create(ValueBase(*current_list.begin()), get_canvas()));
bone_link_node->set_link("base_value",
ValueNode_Composite::create(
ValueTransformation::back_transform(
bone_link_node->get_bone_transformation(time),
value_desc.get_value(time) )));
node = bone_link_node;
}
if (!node) continue;
// enqueue suitable action to assign node
if (value_desc.parent_is_canvas())
{
Action::Handle action = ValueNodeReplace::create();
action->set_param("canvas", get_canvas());
action->set_param("canvas_interface", get_canvas_interface());
action->set_param("src", node);
action->set_param("dest", value_desc.get_value_node());
assert(action->is_ready());
if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY);
add_action_front(action);
}
else
if (value_desc.parent_is_layer())
{
Action::Handle action = LayerParamConnect::create();
action->set_param("layer", value_desc.get_layer());
action->set_param("param", value_desc.get_param_name());
action->set_param("canvas", get_canvas());
action->set_param("canvas_interface", get_canvas_interface());
action->set_param("value_node", node);
assert(action->is_ready());
if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY);
add_action_front(action);
}
else
if (value_desc.parent_is_value_node())
{
Action::Handle action = ValueNodeLinkConnect::create();
action->set_param("canvas", get_canvas());
action->set_param("canvas_interface", get_canvas_interface());
action->set_param("parent_value_node", value_desc.get_parent_value_node());
action->set_param("index", value_desc.get_index());
action->set_param("value_node", node);
assert(action->is_ready());
if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY);
add_action_front(action);
}
}
}
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();
}
main()
{
Set<int> s;
assert(s.size() == 0);
assert(s.empty());
s.insert(10);
Set<int>::iterator iter = s.begin();
assert(*iter == 10);
s.insert(6);
s.insert(6);
assert(s.count(6) == 1);
assert(s.count(10) == 1);
assert(s.count(12) == 0);
iter = s.begin();
assert(*iter == 6);
++iter;
assert(*iter == 10);
++iter;
assert(iter == s.end());
s.insert(7);
s.insert(9);
s.insert(9);
s.insert(8);
s.insert(11);
iter = s.begin();
assert(*iter == 6);
++iter;
assert(*iter == 7);
++iter;
assert(*iter == 8);
++iter;
assert(*iter == 9);
++iter;
assert(*iter == 10);
++iter;
assert(*iter == 11);
Set<int> s2;
s2.insert(3);
s2.insert(7);
s2.insert(-1);
s2.insert(16);
s2.insert(11);
s2.insert(4);
iter = s2.find(3);
assert(*iter == 3);
iter = s2.find(888);
assert(iter == s2.end());
s2.erase(7);
iter = s2.begin();
assert(*iter == -1);
++iter;
assert(*iter == 3);
++iter;
assert(*iter == 4);
++iter;
assert(*iter == 11);
++iter;
assert(*iter == 16);
++iter;
assert(iter == s2.end());
s2.erase(16);
iter = s2.begin();
assert(*iter == -1);
++iter;
assert(*iter == 3);
++iter;
assert(*iter == 4);
++iter;
assert(*iter == 11);
++iter;
assert(iter == s2.end());
s2.erase(3);
iter = s2.begin();
assert(*iter == -1);
++iter;
assert(*iter == 4);
++iter;
assert(*iter == 11);
++iter;
assert(iter == s2.end());
s2.erase(11);
iter = s2.begin();
assert(*iter == -1);
++iter;
assert(*iter == 4);
++iter;
assert(iter == s2.end());
s2.erase(-1);
iter = s2.begin();
assert(*iter == 4);
++iter;
assert(iter == s2.end());
s2.erase(4);
iter = s2.begin();
assert(iter == s2.end());
cout << "All tests passed." << 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;
}
