/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_void_t tb_sort(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_iterator_comp_t comp)
{
// check
tb_assert_and_check_return(iterator);
// no elements?
tb_check_return(head != tail);
// readonly?
tb_assert_and_check_return(!(tb_iterator_mode(iterator) & TB_ITERATOR_MODE_READONLY));
#ifdef TB_CONFIG_MICRO_ENABLE
// random access iterator?
tb_assert_and_check_return(tb_iterator_mode(iterator) & TB_ITERATOR_MODE_RACCESS);
// sort it
tb_quick_sort(iterator, head, tail, comp);
#else
// random access iterator?
if (tb_iterator_mode(iterator) & TB_ITERATOR_MODE_RACCESS)
{
if (tb_distance(iterator, head, tail) > 100000) tb_heap_sort(iterator, head, tail, comp);
else tb_quick_sort(iterator, head, tail, comp); //!< @note the recursive stack size is limit
}
else tb_insert_sort(iterator, head, tail, comp);
#endif
}
/*!the insertion sort
*
* <pre>
* old: 5 2 6 2 8 6 1
*
* (hole)
* step1: ((5)) 2 6 2 8 6 1
* (next) <=
*
* (hole)
* step2: ((2)) (5) 6 2 8 6 1
* (next) <=
*
* (hole)
* step3: 2 5 ((6)) 2 8 6 1
* (next) <=
*
* (hole)
* step4: 2 ((2)) (5) (6) 8 6 1
* (next) <=
*
* (hole)
* step5: 2 2 5 6 ((8)) 6 1
* (next) <=
*
* (hole)
* step6: 2 2 5 6 ((6)) (8) 1
* (next) <=
*
* (hole)
* step7: ((1)) (2) (2) (5) (6) (6) (8)
* (next)
* </pre>
*/
tb_void_t tb_insert_sort(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_iterator_comp_t comp)
{
// check
tb_assert_and_check_return(iterator);
tb_assert_and_check_return((tb_iterator_mode(iterator) & TB_ITERATOR_MODE_FORWARD));
tb_assert_and_check_return((tb_iterator_mode(iterator) & TB_ITERATOR_MODE_REVERSE));
tb_check_return(head != tail);
// init
tb_size_t step = tb_iterator_step(iterator);
tb_pointer_t temp = step > sizeof(tb_pointer_t)? tb_malloc(step) : tb_null;
tb_assert_and_check_return(step <= sizeof(tb_pointer_t) || temp);
// the comparer
if (!comp) comp = tb_iterator_comp;
// sort
tb_size_t last, next;
for (next = tb_iterator_next(iterator, head); next != tail; next = tb_iterator_next(iterator, next))
{
// save next
if (step <= sizeof(tb_pointer_t)) temp = tb_iterator_item(iterator, next);
else tb_memcpy(temp, tb_iterator_item(iterator, next), step);
// look for hole and move elements[hole, next - 1] => [hole + 1, next]
for (last = next; last != head && (last = tb_iterator_prev(iterator, last), comp(iterator, temp, tb_iterator_item(iterator, last)) < 0); next = last)
tb_iterator_copy(iterator, next, tb_iterator_item(iterator, last));
// item => hole
tb_iterator_copy(iterator, next, temp);
}
// free
if (temp && step > sizeof(tb_pointer_t)) tb_free(temp);
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_void_t tb_remove_first_if(tb_iterator_ref_t iterator, tb_predicate_ref_t pred, tb_cpointer_t value)
{
// check
tb_assert_and_check_return(iterator && pred);
// the iterator mode
tb_size_t mode = tb_iterator_mode(iterator);
tb_assert_and_check_return((mode & TB_ITERATOR_MODE_FORWARD));
tb_assert_and_check_return(!(mode & TB_ITERATOR_MODE_READONLY));
// done
tb_size_t itor = tb_iterator_head(iterator);
while (itor != tb_iterator_tail(iterator))
{
// done predicate
if (pred(iterator, tb_iterator_item(iterator, itor), value))
{
// remove it
tb_iterator_remove(iterator, itor);
break;
}
// next
itor = tb_iterator_next(iterator, itor);
}
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_size_t tb_rwalk(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_rwalk_func_t func, tb_cpointer_t priv)
{
// check
tb_assert_and_check_return_val(iterator && (tb_iterator_mode(iterator) & TB_ITERATOR_MODE_REVERSE) && func, 0);
// null?
tb_check_return_val(head != tail, 0);
// rwalk
tb_size_t count = 0;
tb_rfor (tb_pointer_t, item, head, tail, iterator)
{
// done
if (!func(iterator, item, priv)) break;
// count++
count++;
}
// ok?
return count;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_size_t tb_rfind_if(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_predicate_ref_t pred, tb_cpointer_t value)
{
// check
tb_assert_and_check_return_val(pred && iterator && (tb_iterator_mode(iterator) & TB_ITERATOR_MODE_REVERSE), tb_iterator_tail(iterator));
// null?
tb_check_return_val(head != tail, tb_iterator_tail(iterator));
// find
tb_size_t itor = tail;
tb_bool_t find = tb_false;
do
{
// the previous item
itor = tb_iterator_prev(iterator, itor);
// comp
if ((find = pred(iterator, tb_iterator_item(iterator, itor), value))) break;
} while (itor != head);
// ok?
return find? itor : tb_iterator_tail(iterator);
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_void_t tb_remove_if(tb_iterator_ref_t iterator, tb_iterator_comp_t comp, tb_cpointer_t priv)
{
// check
tb_assert_and_check_return(iterator && comp);
// the iterator mode
tb_size_t mode = tb_iterator_mode(iterator);
tb_assert_and_check_return((mode & TB_ITERATOR_MODE_FORWARD));
tb_assert_and_check_return(!(mode & TB_ITERATOR_MODE_READONLY));
// done
tb_long_t ok = 1;
tb_size_t size = 0;
tb_bool_t stop = tb_false;
tb_bool_t need = tb_false;
tb_size_t prev = tb_iterator_tail(iterator);
tb_size_t itor = tb_iterator_head(iterator);
tb_size_t base = tb_iterator_tail(iterator);
tb_bool_t bmutable = (mode & TB_ITERATOR_MODE_MUTABLE)? tb_true : tb_false;
while (itor != tb_iterator_tail(iterator))
{
// save next
tb_size_t next = tb_iterator_next(iterator, itor);
// done func
if ((ok = comp(iterator, tb_iterator_item(iterator, itor), priv)) < 0) stop = tb_true;
// remove it?
if (!ok)
{
// is the first removed item?
if (!need)
{
// save the removed range base
base = prev;
// need remove items
need = tb_true;
}
// update size
size++;
}
// the removed range have been passed or stop or end?
if (ok || next == tb_iterator_tail(iterator))
{
// need remove items?
if (need)
{
// check
tb_assert_abort(size);
// the previous tail
tb_size_t prev_tail = tb_iterator_tail(iterator);
// remove items
tb_iterator_remove_range(iterator, base, !ok? next : itor, size);
// reset state
need = tb_false;
size = 0;
// is the mutable iterator?
if (bmutable)
{
// update itor
prev = base;
// the body items are removed?
if (base != prev_tail)
{
// the next itor
itor = tb_iterator_next(iterator, base);
// the last item be not removed? skip the last walked item
if (ok)
{
prev = itor;
itor = tb_iterator_next(iterator, itor);
}
}
// the head items are removed?
else itor = tb_iterator_head(iterator);
// stop?
tb_check_break(!stop);
// continue?
continue ;
}
}
// stop?
tb_check_break(!stop);
}
// next
prev = itor;
itor = next;
}
}