bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap1>));
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap2>));
// if this assertion is triggered, the value_compare types are incompatible
BOOST_STATIC_ASSERT((boost::is_same<typename Heap1::value_compare, typename Heap2::value_compare>::value));
if (Heap1::constant_time_size && Heap2::constant_time_size)
if (lhs.size() != rhs.size())
return false;
if (lhs.empty() && rhs.empty())
return true;
typename Heap1::ordered_iterator it1 = lhs.ordered_begin();
typename Heap1::ordered_iterator it1_end = lhs.ordered_end();
typename Heap1::ordered_iterator it2 = rhs.ordered_begin();
typename Heap1::ordered_iterator it2_end = rhs.ordered_end();
while (true) {
if (!value_equality(lhs, rhs, *it1, *it2))
return false;
++it1;
++it2;
if (it1 == it1_end && it2 == it2_end)
return true;
if (it1 == it1_end || it2 == it2_end)
return false;
}
}
bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap1>));
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap2>));
// if this assertion is triggered, the value_compare types are incompatible
BOOST_STATIC_ASSERT((boost::is_same<typename Heap1::value_compare, typename Heap2::value_compare>::value));
if (Heap1::constant_time_size && Heap2::constant_time_size)
if (lhs.size() != rhs.size())
return false;
if (lhs.empty() && rhs.empty())
return true;
Heap1 lhs_copy(lhs);
Heap2 rhs_copy(rhs);
while (true) {
if (!value_equality(lhs_copy, rhs_copy, lhs_copy.top(), rhs_copy.top()))
return false;
lhs_copy.pop();
rhs_copy.pop();
if (lhs_copy.empty() && rhs_copy.empty())
return true;
if (lhs_copy.empty())
return false;
if (rhs_copy.empty())
return false;
}
}
bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
typename Heap1::size_type left_size = lhs.size();
typename Heap2::size_type right_size = rhs.size();
if (left_size < right_size)
return true;
if (left_size > right_size)
return false;
typename Heap1::ordered_iterator it1 = lhs.ordered_begin();
typename Heap1::ordered_iterator it1_end = lhs.ordered_end();
typename Heap1::ordered_iterator it2 = rhs.ordered_begin();
typename Heap1::ordered_iterator it2_end = rhs.ordered_end();
while (true) {
if (value_compare(lhs, rhs, *it1, *it2))
return true;
if (value_compare(lhs, rhs, *it2, *it1))
return false;
++it1;
++it2;
if (it1 == it1_end && it2 == it2_end)
return true;
if (it1 == it1_end || it2 == it2_end)
return false;
}
}
bool value_equality(Heap1 const & lhs, Heap2 const & rhs,
typename Heap1::value_type lval, typename Heap2::value_type rval)
{
typename Heap1::value_compare const & cmp = lhs.value_comp();
bool ret = !(cmp(lval, rval)) && !(cmp(rval, lval));
// if this assertion is triggered, the value_compare objects of lhs and rhs return different values
BOOST_ASSERT((ret == (!(rhs.value_comp()(lval, rval)) && !(rhs.value_comp()(rval, lval)))));
return ret;
}
bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
typename Heap1::size_type left_size = lhs.size();
typename Heap2::size_type right_size = rhs.size();
if (left_size < right_size)
return true;
if (left_size > right_size)
return false;
Heap1 lhs_copy(lhs);
Heap2 rhs_copy(rhs);
while (true) {
if (value_compare(lhs_copy, rhs_copy, lhs_copy.top(), rhs_copy.top()))
return true;
if (value_compare(lhs_copy, rhs_copy, rhs_copy.top(), lhs_copy.top()))
return false;
lhs_copy.pop();
rhs_copy.pop();
if (lhs_copy.empty() && rhs_copy.empty())
return false;
}
}
static void merge(Heap1 & lhs, Heap2 & rhs)
{
if (Heap1::constant_time_size && Heap2::constant_time_size) {
if (Heap1::has_reserve) {
std::size_t required_size = lhs.size() + rhs.size();
space_reserver::reserve(lhs, required_size);
}
}
// FIXME: container adaptors could benefit from first appending all elements and then restoring the heap order
// FIXME: optimize: if we have ordered iterators and we can efficiently insert keys with a below the lowest key in the heap
// d-ary, b and fibonacci heaps fall into this category
while (!rhs.empty()) {
lhs.push(rhs.top());
rhs.pop();
}
lhs.set_stability_count((std::max)(lhs.get_stability_count(),
rhs.get_stability_count()));
rhs.set_stability_count(0);
}