SplayTree& SplayTree::operator=(const SplayTree& t)
{
this->clear();
compare_functor = t.compare_functor;
copy_functor = t.copy_functor;
delete_functor = t.delete_functor;
insert_range(t.front(), NULL);
if (likely(NULL != header.child[LEFT]))
{
splay(header.child[LEFT]);
}
return *this;
}
modification
invert (modification m, tree t) {
ASSERT (is_applicable (t, m), "modification not applicable");
path rp= root (m);
switch (m->k) {
case MOD_ASSIGN:
return mod_assign (rp, copy (subtree (t, rp)));
case MOD_INSERT:
return mod_remove (rp, index (m), insert_length (m->t));
case MOD_REMOVE:
{
int i= index (m);
int n= argument (m);
return mod_insert (rp, i, copy (insert_range (subtree (t, rp), i, n)));
}
case MOD_SPLIT:
return mod_join (rp, index (m));
case MOD_JOIN:
{
int i= index (m);
return mod_split (rp, i, insert_length (subtree (t, rp * i)));
}
case MOD_ASSIGN_NODE:
return mod_assign_node (rp, L (subtree (t, rp)));
case MOD_INSERT_NODE:
return mod_remove_node (rp, argument (m));
case MOD_REMOVE_NODE:
{
tree u= subtree (t, rp);
int i= index (m);
return mod_insert_node (rp, i, copy (u (0, i) * u (i+1, N(u))));
}
case MOD_SET_CURSOR:
return m;
default:
FAILED ("unexpected situation");
}
}
void fill(TContainer& container) {
rrange_insert<TContainer, typename TContainer::iterator> insert_range(container, container.begin());
while (range_.ok() && range_.take2(insert_range));
}
static void
frob_range (ADDR_RANGE *ar, address_word start, address_word end, int delete_p)
{
ADDR_SUBRANGE *asr;
ADDR_SUBRANGE *new_asr, *new_asr2;
ADDR_SUBRANGE *left = NULL;
ADDR_SUBRANGE *right = NULL;
ADDR_SUBRANGE **before;
ADDR_SUBRANGE init_caller;
ADDR_SUBRANGE *caller = &init_caller;
int added_p = 0;
memset (caller, 0, sizeof (ADDR_SUBRANGE));
new_asr = ZALLOC (ADDR_SUBRANGE);
new_asr2 = ZALLOC (ADDR_SUBRANGE);
caller->start = start;
caller->end = end;
before = &ar->ranges;
while ((asr = *before) != NULL)
{
if (! delete_p)
{
/* Try next range if current range preceeds new one and not
adjacent or overlapping. */
if (asr->end < caller->start - 1)
goto next_range;
/* Break out if new range preceeds current one and not
adjacent or overlapping. */
if (asr->start > caller->end + 1)
break;
/* If we come here, the new and current ranges are adjacent or
overlapping. Make one range yielding from the lower start address
of both ranges to the higher end address. */
if (asr->start > caller->start)
asr->start = caller->start;
else
caller->start = asr->start;
if (asr->end < caller->end)
asr->end = caller->end;
else
caller->end = asr->end;
if (added_p)
{
delete_range (before);
continue;
}
caller = asr;
added_p = 1;
}
else /* deleting a range */
{
/* Try next range if current range preceeds new one. */
if (asr->end < caller->start)
goto next_range;
/* Break out if new range preceeds current one. */
if (asr->start > caller->end)
break;
added_p = 1;
if (asr->start < caller->start)
left = asr;
/* If the next range in the list has a higher end
address than the new one, insert the new one here. */
if (asr->end > caller->end)
{
right = asr;
break;
}
if (asr->start >= caller->start)
{
/* The new range completely replaces an old
one (This may happen several times). */
if (added_p)
{
delete_range (before);
continue;
}
/* Replace the old range with the new one. */
asr->start = caller->start;
asr->end = caller->end;
caller = asr;
added_p = 1;
}
}
/* Go on to next range. */
next_range:
before = &asr->next;
}
if (!added_p)
{
if (delete_p)
goto out;
new_asr->start = caller->start;
new_asr->end = caller->end;
insert_range (before, new_asr);
new_asr = NULL;
}
if (right)
{
if (left == right)
{
/* The new range breaks the old one in two pieces,
so we have to use the second new range. */
new_asr2->start = right->start;
new_asr2->end = right->end;
left = new_asr2;
insert_range (before, left);
new_asr2 = NULL;
}
right->start = caller->end + 1;
}
if (left)
{
left->end = caller->start - 1;
}
out:
if (new_asr)
free(new_asr);
if (new_asr2)
free(new_asr2);
}
unordered_map& operator=(std::initializer_list<value_type> list)
{
base.data_.clear();
base.insert_range(list.begin(), list.end());
return *this;
}
