bool HashTree::getChangedHashes(std::vector< std::shared_ptr<Hash> >& changed_hashes,
const HashTree& lhs) const
{
if (this->checkHashTreeChange(lhs))
{
int max_elements_size = lhs.getElementsPerLevel()->front() + elements_per_level_.front();
changed_hashes.resize(max_elements_size);
std::vector< std::shared_ptr<Hash> > left_hashes(lhs.getElementsPerLevel()->front());
std::vector< std::shared_ptr<Hash> > left_hashes_unique(lhs.getElementsPerLevel()->front());
std::copy_n (lhs.getHashes()->begin(), lhs.getElementsPerLevel()->front(), left_hashes.begin());
std::vector< std::shared_ptr<Hash> > right_hashes(elements_per_level_.front());
std::vector< std::shared_ptr<Hash> > right_hashes_unique(elements_per_level_.front());
std::copy_n (hashes_.begin(), elements_per_level_.front(), right_hashes.begin());
std::sort (left_hashes.begin(), left_hashes.end(), hashSharedPointerLessThanFunctor());
std::sort (right_hashes.begin(), right_hashes.end(), hashSharedPointerLessThanFunctor());
std::vector< std::shared_ptr<Hash> >::iterator it;
it = std::unique_copy (left_hashes.begin(), left_hashes.end(), left_hashes_unique.begin(), hashSharedPointerEqualsFunctor());
left_hashes_unique.resize(std::distance(left_hashes_unique.begin(),it));
it = std::unique_copy (right_hashes.begin(), right_hashes.end(), right_hashes_unique.begin(), hashSharedPointerEqualsFunctor());
right_hashes_unique.resize(std::distance(right_hashes_unique.begin(),it));
it = set_symmetric_difference(left_hashes_unique.begin(), left_hashes_unique.end(),
right_hashes_unique.begin(), right_hashes_unique.end(),
changed_hashes.begin(), hashSharedPointerLessThanFunctor());
changed_hashes.resize(std::distance(changed_hashes.begin(),it));
return true;
} else {
return false;
}
}
mixed *set_difference(mixed *a, mixed *b, varargs int r) {
mixed *c;
c = set_intersection(a, set_symmetric_difference(a, b));
return r ? set_remove_repeats(c) : c;
}
Set<V> SymmetricDifference(const Set<V>& s1, const Set<V>& s2)
{
set<V> mysdiff;
set<V>::iterator i = mysdiff.begin();
insert_iterator<set<V> > insertiter(mysdiff, i);
set_symmetric_difference(s1.s.begin(), s1.s.end(), s2.s.begin(), s2.s.end(), insertiter);
return Set<V>(mysdiff);
}
STATIC mp_obj_t set_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_t args[] = {lhs, rhs};
switch (op) {
case RT_BINARY_OP_OR:
return set_union(lhs, rhs);
case RT_BINARY_OP_XOR:
return set_symmetric_difference(lhs, rhs);
case RT_BINARY_OP_AND:
return set_intersect(lhs, rhs);
case RT_BINARY_OP_SUBTRACT:
return set_diff(2, args);
case RT_BINARY_OP_INPLACE_OR:
return set_union(lhs, rhs);
case RT_BINARY_OP_INPLACE_XOR:
return set_symmetric_difference(lhs, rhs);
case RT_BINARY_OP_INPLACE_AND:
return set_intersect(lhs, rhs);
case RT_BINARY_OP_INPLACE_SUBTRACT:
return set_diff(2, args);
case RT_BINARY_OP_LESS:
return set_issubset_proper(lhs, rhs);
case RT_BINARY_OP_MORE:
return set_issuperset_proper(lhs, rhs);
case RT_BINARY_OP_EQUAL:
return set_equal(lhs, rhs);
case RT_BINARY_OP_LESS_EQUAL:
return set_issubset(lhs, rhs);
case RT_BINARY_OP_MORE_EQUAL:
return set_issuperset(lhs, rhs);
case RT_BINARY_OP_NOT_EQUAL:
return MP_BOOL(set_equal(lhs, rhs) == mp_const_false);
case RT_BINARY_OP_IN:
{
mp_obj_set_t *o = lhs;
mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);
return MP_BOOL(elem != NULL);
}
default:
// op not supported
return NULL;
}
}
void set_algo(){
cout<<endl<<"set_algo :"<<endl;
int ia1[6] = { 1, 3, 5, 6, 7, 8 };
int ia2[9] = {0, 2, 4, 5, 6, 7, 8 };
std::set<int> s1(ia1,ia1+6); std::set<int> s2(ia2,ia2+9);
std::set<int> s3; vector<int> s4,s5,s6;
set_union(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s3,s3.begin()));
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),back_inserter(s4));
set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),back_inserter(s5));
set_symmetric_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),back_inserter(s6));
cout<<s1<<s2<<s3<<s4<<endl<<s5<<endl<<s6<<endl;
}
PluginMetadata PluginMetadata::DiffMetadata(const PluginMetadata& plugin) const {
BOOST_LOG_TRIVIAL(trace) << "Calculating metadata difference for: " << name;
PluginMetadata p(*this);
if (priority == plugin.Priority()) {
p.Priority(0);
p.SetPriorityExplicit(false);
}
//Compare this plugin against the given plugin.
set<File> files = plugin.LoadAfter();
set<File> filesDiff;
set_symmetric_difference(loadAfter.begin(), loadAfter.end(), files.begin(), files.end(), inserter(filesDiff, filesDiff.begin()));
p.LoadAfter(filesDiff);
filesDiff.clear();
files = plugin.Reqs();
set_symmetric_difference(requirements.begin(), requirements.end(), files.begin(), files.end(), inserter(filesDiff, filesDiff.begin()));
p.Reqs(filesDiff);
filesDiff.clear();
files = plugin.Incs();
set_symmetric_difference(incompatibilities.begin(), incompatibilities.end(), files.begin(), files.end(), inserter(filesDiff, filesDiff.begin()));
p.Incs(filesDiff);
list<Message> msgs1 = plugin.Messages();
list<Message> msgs2 = messages;
msgs1.sort();
msgs2.sort();
list<Message> mDiff;
set_symmetric_difference(msgs2.begin(), msgs2.end(), msgs1.begin(), msgs1.end(), inserter(mDiff, mDiff.begin()));
p.Messages(mDiff);
set<Tag> bashTags = plugin.Tags();
set<Tag> tagDiff;
set_symmetric_difference(tags.begin(), tags.end(), bashTags.begin(), bashTags.end(), inserter(tagDiff, tagDiff.begin()));
p.Tags(tagDiff);
set<PluginDirtyInfo> dirtyInfo = plugin.DirtyInfo();
set<PluginDirtyInfo> dirtDiff;
set_symmetric_difference(_dirtyInfo.begin(), _dirtyInfo.end(), dirtyInfo.begin(), dirtyInfo.end(), inserter(dirtDiff, dirtDiff.begin()));
p.DirtyInfo(dirtDiff);
set<Location> locations = plugin.Locations();
set<Location> locationsDiff;
set_symmetric_difference(_locations.begin(), _locations.end(), locations.begin(), locations.end(), inserter(locationsDiff, locationsDiff.begin()));
p.Locations(locationsDiff);
return p;
}
int main()
{
string str1[] = { "Pooh", "Piglet", "Tigger", "Eeyore" };
string str2[] = { "Pooh", "Heffalump", "Woozles" };
ostream_iterator< string > ofile( cout, " " );
set<string,less<string>,allocator> set1( str1, str1+4 );
set<string,less<string>,allocator> set2( str2, str2+3 );
cout << "set #1 elements:\n\t";
copy( set1.begin(), set1.end(), ofile ); cout << "\n\n";
cout << "set #2 elements:\n\t";
copy( set2.begin(), set2.end(), ofile ); cout << "\n\n";
set<string,less<string>,allocator> res;
set_union( set1.begin(), set1.end(),
set2.begin(), set2.end(),
inserter( res, res.begin() ));
cout << "set_union() elements:\n\t";
copy( res.begin(), res.end(), ofile ); cout << "\n\n";
res.clear();
set_intersection( set1.begin(), set1.end(),
set2.begin(), set2.end(),
inserter( res, res.begin() ));
cout << "set_intersection() elements:\n\t";
copy( res.begin(), res.end(), ofile ); cout << "\n\n";
res.clear();
set_difference( set1.begin(), set1.end(),
set2.begin(), set2.end(),
inserter( res, res.begin() ));
cout << "set_difference() elements:\n\t";
copy( res.begin(), res.end(), ofile ); cout << "\n\n";
res.clear();
set_symmetric_difference( set1.begin(), set1.end(),
set2.begin(), set2.end(),
inserter( res, res.begin() ));
cout << "set_symmetric_difference() elements:\n\t";
copy( res.begin(), res.end(), ofile ); cout << "\n\n";
}
vector<int> Hypergraph::getGraphDifference(const Hypergraph *newGraph)
{
const vector<HyperEdge> &newEdges = newGraph->_edges;
vector<int> diffSet (0);
int nEdges = _edges.size();
int nNewEdges = newEdges.size();
int i=0;
vector<int>::iterator it = diffSet.begin();
for (; i<min(nEdges, nNewEdges); ++i)
{
vector<int> v(_edges[i].size()+newEdges[i].size());
vector<int>::iterator vIt = set_symmetric_difference(_edges[i].begin(), _edges[i].end(), newEdges[i].begin(), newEdges[i].end(), v.begin());
int originalSize = diffSet.size();
diffSet.resize(vIt-v.begin()+diffSet.size());
copy(v.begin(), vIt, diffSet.begin()+originalSize);
}
for (;i<nEdges; ++i)
{
int originalSize = diffSet.size();
diffSet.resize(diffSet.size()+_edges[i].size());
copy(_edges[i].begin(), _edges[i].end(), diffSet.begin()+originalSize);
}
for (;i<nNewEdges; ++i)
{
int originalSize = diffSet.size();
diffSet.resize(diffSet.size()+newEdges[i].size());
copy(_edges[i].begin(), _edges[i].end(), diffSet.begin()+originalSize);
}
sort(diffSet.begin(), diffSet.end());
it = unique(diffSet.begin(), diffSet.end());
diffSet.resize(it-diffSet.begin());
return diffSet;
}
static void TestAlgorithms (void)
{
static const int c_TestNumbers[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15, 16, 17, 18 };
const int* first = c_TestNumbers;
const int* last = first + VectorSize(c_TestNumbers);
intvec_t v, buf;
v.assign (first, last);
PrintVector (v);
cout << "swap(1,2)\n";
swap (v[0], v[1]);
PrintVector (v);
v.assign (first, last);
cout << "copy(0,8,9)\n";
copy (v.begin(), v.begin() + 8, v.begin() + 9);
PrintVector (v);
v.assign (first, last);
cout << "copy with back_inserter\n";
v.clear();
copy (first, last, back_inserter(v));
PrintVector (v);
v.assign (first, last);
cout << "copy with inserter\n";
v.clear();
copy (first, first + 5, inserter(v, v.begin()));
copy (first, first + 5, inserter(v, v.begin() + 3));
PrintVector (v);
v.assign (first, last);
cout << "copy_n(0,8,9)\n";
copy_n (v.begin(), 8, v.begin() + 9);
PrintVector (v);
v.assign (first, last);
cout << "copy_if(is_even)\n";
intvec_t v_even;
copy_if (v, back_inserter(v_even), &is_even);
PrintVector (v_even);
v.assign (first, last);
cout << "for_each(printint)\n{ ";
for_each (v, &printint);
cout << "}\n";
cout << "for_each(reverse_iterator, printint)\n{ ";
for_each (v.rbegin(), v.rend(), &printint);
cout << "}\n";
cout << "find(10)\n";
cout.format ("10 found at offset %zd\n", abs_distance (v.begin(), find (v, 10)));
cout << "count(13)\n";
cout.format ("%zu values of 13, %zu values of 18\n", count(v,13), count(v,18));
cout << "transform(sqr)\n";
transform (v, &sqr);
PrintVector (v);
v.assign (first, last);
cout << "replace(13,666)\n";
replace (v, 13, 666);
PrintVector (v);
v.assign (first, last);
cout << "fill(13)\n";
fill (v, 13);
PrintVector (v);
v.assign (first, last);
cout << "fill_n(5, 13)\n";
fill_n (v.begin(), 5, 13);
PrintVector (v);
v.assign (first, last);
cout << "fill 64083 uint8_t(0x41) ";
TestBigFill<uint8_t> (64083, 0x41);
cout << "fill 64083 uint16_t(0x4142) ";
TestBigFill<uint16_t> (64083, 0x4142);
cout << "fill 64083 uint32_t(0x41424344) ";
TestBigFill<uint32_t> (64083, 0x41424344);
cout << "fill 64083 float(0.4242) ";
TestBigFill<float> (64083, 0x4242f);
#if HAVE_INT64_T
cout << "fill 64083 uint64_t(0x4142434445464748) ";
TestBigFill<uint64_t> (64083, UINT64_C(0x4142434445464748));
#else
cout << "No 64bit types available on this platform\n";
#endif
cout << "copy 64083 uint8_t(0x41) ";
TestBigCopy<uint8_t> (64083, 0x41);
cout << "copy 64083 uint16_t(0x4142) ";
TestBigCopy<uint16_t> (64083, 0x4142);
cout << "copy 64083 uint32_t(0x41424344) ";
TestBigCopy<uint32_t> (64083, 0x41424344);
cout << "copy 64083 float(0.4242) ";
TestBigCopy<float> (64083, 0.4242f);
#if HAVE_INT64_T
cout << "copy 64083 uint64_t(0x4142434445464748) ";
TestBigCopy<uint64_t> (64083, UINT64_C(0x4142434445464748));
#else
cout << "No 64bit types available on this platform\n";
#endif
cout << "generate(genint)\n";
generate (v, &genint);
PrintVector (v);
v.assign (first, last);
cout << "rotate(4)\n";
rotate (v, 7);
rotate (v, -3);
PrintVector (v);
v.assign (first, last);
cout << "merge with (3,5,10,11,11,14)\n";
const int c_MergeWith[] = { 3,5,10,11,11,14 };
intvec_t vmerged;
merge (v.begin(), v.end(), VectorRange(c_MergeWith), back_inserter(vmerged));
PrintVector (vmerged);
v.assign (first, last);
cout << "inplace_merge with (3,5,10,11,11,14)\n";
v.insert (v.end(), VectorRange(c_MergeWith));
inplace_merge (v.begin(), v.end() - VectorSize(c_MergeWith), v.end());
PrintVector (v);
v.assign (first, last);
cout << "remove(13)\n";
remove (v, 13);
PrintVector (v);
v.assign (first, last);
cout << "remove (elements 3, 4, 6, 15, and 45)\n";
vector<uoff_t> toRemove;
toRemove.push_back (3);
toRemove.push_back (4);
toRemove.push_back (6);
toRemove.push_back (15);
toRemove.push_back (45);
typedef index_iterate<intvec_t::iterator, vector<uoff_t>::iterator> riiter_t;
riiter_t rfirst = index_iterator (v.begin(), toRemove.begin());
riiter_t rlast = index_iterator (v.begin(), toRemove.end());
remove (v, rfirst, rlast);
PrintVector (v);
v.assign (first, last);
cout << "unique\n";
unique (v);
PrintVector (v);
v.assign (first, last);
cout << "reverse\n";
reverse (v);
PrintVector (v);
v.assign (first, last);
cout << "lower_bound(10)\n";
PrintVector (v);
cout.format ("10 begins at position %zd\n", abs_distance (v.begin(), lower_bound (v, 10)));
v.assign (first, last);
cout << "upper_bound(10)\n";
PrintVector (v);
cout.format ("10 ends at position %zd\n", abs_distance (v.begin(), upper_bound (v, 10)));
v.assign (first, last);
cout << "equal_range(10)\n";
PrintVector (v);
TestEqualRange (v);
v.assign (first, last);
cout << "sort\n";
reverse (v);
PrintVector (v);
random_shuffle (v);
sort (v);
PrintVector (v);
v.assign (first, last);
cout << "stable_sort\n";
reverse (v);
PrintVector (v);
random_shuffle (v);
stable_sort (v);
PrintVector (v);
v.assign (first, last);
cout << "is_sorted\n";
random_shuffle (v);
const bool bNotSorted = is_sorted (v.begin(), v.end());
sort (v);
const bool bSorted = is_sorted (v.begin(), v.end());
cout << "unsorted=" << bNotSorted << ", sorted=" << bSorted << endl;
v.assign (first, last);
cout << "find_first_of\n";
static const int c_FFO[] = { 10000, -34, 14, 27 };
cout.format ("found 14 at position %zd\n", abs_distance (v.begin(), find_first_of (v.begin(), v.end(), VectorRange(c_FFO))));
v.assign (first, last);
static const int LC1[] = { 3, 1, 4, 1, 5, 9, 3 };
static const int LC2[] = { 3, 1, 4, 2, 8, 5, 7 };
static const int LC3[] = { 1, 2, 3, 4 };
static const int LC4[] = { 1, 2, 3, 4, 5 };
cout << "lexicographical_compare";
cout << "\nLC1 < LC2 == " << lexicographical_compare (VectorRange(LC1), VectorRange(LC2));
cout << "\nLC2 < LC2 == " << lexicographical_compare (VectorRange(LC2), VectorRange(LC2));
cout << "\nLC3 < LC4 == " << lexicographical_compare (VectorRange(LC3), VectorRange(LC4));
cout << "\nLC4 < LC1 == " << lexicographical_compare (VectorRange(LC4), VectorRange(LC1));
cout << "\nLC1 < LC4 == " << lexicographical_compare (VectorRange(LC1), VectorRange(LC4));
cout << "\nmax_element\n";
cout.format ("max element is %d\n", *max_element (v.begin(), v.end()));
v.assign (first, last);
cout << "min_element\n";
cout.format ("min element is %d\n", *min_element (v.begin(), v.end()));
v.assign (first, last);
cout << "partial_sort\n";
reverse (v);
partial_sort (v.begin(), v.iat(v.size() / 2), v.end());
PrintVector (v);
v.assign (first, last);
cout << "partial_sort_copy\n";
reverse (v);
buf.resize (v.size());
partial_sort_copy (v.begin(), v.end(), buf.begin(), buf.end());
PrintVector (buf);
v.assign (first, last);
cout << "partition\n";
partition (v.begin(), v.end(), &is_even);
PrintVector (v);
v.assign (first, last);
cout << "stable_partition\n";
stable_partition (v.begin(), v.end(), &is_even);
PrintVector (v);
v.assign (first, last);
cout << "next_permutation\n";
buf.resize (3);
iota (buf.begin(), buf.end(), 1);
PrintVector (buf);
while (next_permutation (buf.begin(), buf.end()))
PrintVector (buf);
cout << "prev_permutation\n";
reverse (buf);
PrintVector (buf);
while (prev_permutation (buf.begin(), buf.end()))
PrintVector (buf);
v.assign (first, last);
cout << "reverse_copy\n";
buf.resize (v.size());
reverse_copy (v.begin(), v.end(), buf.begin());
PrintVector (buf);
v.assign (first, last);
cout << "rotate_copy\n";
buf.resize (v.size());
rotate_copy (v.begin(), v.iat (v.size() / 3), v.end(), buf.begin());
PrintVector (buf);
v.assign (first, last);
static const int c_Search1[] = { 5, 6, 7, 8, 9 }, c_Search2[] = { 10, 10, 11, 14 };
cout << "search\n";
cout.format ("{5,6,7,8,9} at %zd\n", abs_distance (v.begin(), search (v.begin(), v.end(), VectorRange(c_Search1))));
cout.format ("{10,10,11,14} at %zd\n", abs_distance (v.begin(), search (v.begin(), v.end(), VectorRange(c_Search2))));
cout << "find_end\n";
cout.format ("{5,6,7,8,9} at %zd\n", abs_distance (v.begin(), find_end (v.begin(), v.end(), VectorRange(c_Search1))));
cout.format ("{10,10,11,14} at %zd\n", abs_distance (v.begin(), find_end (v.begin(), v.end(), VectorRange(c_Search2))));
cout << "search_n\n";
cout.format ("{14} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 1, 14)));
cout.format ("{13,13} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 2, 13)));
cout.format ("{10,10,10} at %zd\n", abs_distance (v.begin(), search_n (v.begin(), v.end(), 3, 10)));
v.assign (first, last);
cout << "includes\n";
static const int c_Includes[] = { 5, 14, 15, 18, 20 };
cout << "includes=" << includes (v.begin(), v.end(), VectorRange(c_Includes)-1);
cout << ", not includes=" << includes (v.begin(), v.end(), VectorRange(c_Includes));
cout << endl;
static const int c_Set1[] = { 1, 2, 3, 4, 5, 6 }, c_Set2[] = { 4, 4, 6, 7, 8 };
intvec_t::iterator setEnd;
cout << "set_difference\n";
v.resize (4);
setEnd = set_difference (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_symmetric_difference\n";
v.resize (7);
setEnd = set_symmetric_difference (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_intersection\n";
v.resize (2);
setEnd = set_intersection (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
cout << "set_union\n";
v.resize (9);
setEnd = set_union (VectorRange(c_Set1), VectorRange(c_Set2), v.begin());
PrintVector (v);
assert (setEnd == v.end());
v.assign (first, last);
}
STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
mp_obj_t args[] = {lhs, rhs};
#if MICROPY_PY_BUILTINS_FROZENSET
bool update = MP_OBJ_IS_TYPE(lhs, &mp_type_set);
#else
bool update = true;
#endif
if (op != MP_BINARY_OP_CONTAINS && !is_set_or_frozenset(rhs)) {
// For all ops except containment the RHS must be a set/frozenset
return MP_OBJ_NULL;
}
switch (op) {
case MP_BINARY_OP_OR:
return set_union(lhs, rhs);
case MP_BINARY_OP_XOR:
return set_symmetric_difference(lhs, rhs);
case MP_BINARY_OP_AND:
return set_intersect(lhs, rhs);
case MP_BINARY_OP_SUBTRACT:
return set_diff(2, args);
case MP_BINARY_OP_INPLACE_OR:
if (update) {
set_update(2, args);
return lhs;
} else {
return set_union(lhs, rhs);
}
case MP_BINARY_OP_INPLACE_XOR:
if (update) {
set_symmetric_difference_update(lhs, rhs);
return lhs;
} else {
return set_symmetric_difference(lhs, rhs);
}
case MP_BINARY_OP_INPLACE_AND:
rhs = set_intersect_int(lhs, rhs, update);
if (update) {
return lhs;
} else {
return rhs;
}
case MP_BINARY_OP_INPLACE_SUBTRACT:
return set_diff_int(2, args, update);
case MP_BINARY_OP_LESS:
return set_issubset_proper(lhs, rhs);
case MP_BINARY_OP_MORE:
return set_issuperset_proper(lhs, rhs);
case MP_BINARY_OP_EQUAL:
return set_equal(lhs, rhs);
case MP_BINARY_OP_LESS_EQUAL:
return set_issubset(lhs, rhs);
case MP_BINARY_OP_MORE_EQUAL:
return set_issuperset(lhs, rhs);
case MP_BINARY_OP_CONTAINS: {
mp_obj_set_t *o = MP_OBJ_TO_PTR(lhs);
mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);
return mp_obj_new_bool(elem != MP_OBJ_NULL);
}
default:
return MP_OBJ_NULL; // op not supported
}
}
