d1/d82/dyndlist_8cc_source.html

/*

                          Aleph_w


  Data structures & Algorithms

  version 2.0.0b

  https://github.com/lrleon/Aleph-w


  This file is part of Aleph-w library


  Copyright (c) 2002-2026 Leandro Rabindranath Leon


  Permission is hereby granted, free of charge, to any person obtaining a copy

  of this software and associated documentation files (the "Software"), to deal

  in the Software without restriction, including without limitation the rights

  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  copies of the Software, and to permit persons to whom the Software is

  furnished to do so, subject to the following conditions:


  The above copyright notice and this permission notice shall be included in all

  copies or substantial portions of the Software.


  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  SOFTWARE.

*/


# include <gtest/gtest.h>


# include <tpl_dynDlist.H>


using namespace std;

using namespace testing;

using namespace Aleph;


# define Declare_list_n_items(num)            \

  struct List_of_##num##_items : public Test  \

  {                                           \

    size_t n = 0;                             \

    DynDlist<int> list##num;                  \

    DynDlist<int> rlist##num;                 \

    List_of_##num##_items()                   \

      {                                       \

        for (size_t i = 0; i < num; ++i, ++n) \

          list##num.append(i + 1);            \

                                              \

        const DynDlist<int> l = list##num;    \

        rlist##num = l.rev();                 \

      }                                       \

  };


Declare_list_n_items(25);

Declare_list_n_items(10);


TEST(DynDlist, Basic_operations)

{

  DynDlist<int> list;

  EXPECT_TRUE(list.is_empty());

  EXPECT_FALSE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());


  list.append(2);

  EXPECT_FALSE(list.is_empty());

  EXPECT_TRUE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());

  EXPECT_EQ(list.get_first(), list.get_last());


  list.insert(1);

  EXPECT_FALSE(list.is_empty());

  EXPECT_FALSE(list.is_unitarian());

  EXPECT_FALSE(list.is_unitarian_or_empty());


  EXPECT_EQ(list.get_first(), 1);

  EXPECT_EQ(list.get_last(), 2);


  list.insert(0);

  list.append(3);

  EXPECT_EQ(list.get_first(), 0);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 0);

  EXPECT_EQ(list.size(), 3);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 1);

  EXPECT_EQ(list.size(), 2);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 2);

  EXPECT_EQ(list.size(), 1);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_TRUE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());


  EXPECT_EQ(list.remove_first(), 3);

  EXPECT_TRUE(list.is_empty());

  EXPECT_EQ(list.size(), 0);


  EXPECT_THROW(list.rotate_left(1), std::domain_error);

  EXPECT_NO_THROW(list.rotate_left(0));

}


TEST(DynDlist, Simple_append_and_insert_of_list)

{

  {                                // by copy

    DynDlist<int> laux, list;

    laux.insert(2);                // laux = { 2 }

    list.append(laux);             // list = { 2 }


    EXPECT_FALSE(laux.is_empty());

    EXPECT_FALSE(list.is_empty());

    EXPECT_EQ(list.get_first(), 2);

    EXPECT_EQ(list.get_first(), laux.get_first());

    EXPECT_TRUE(list.is_unitarian());


    laux.insert(1);                // laux = { 1, 2 }

    list.insert(laux);             // list = { 1, 2, 2 }

    EXPECT_FALSE(laux.is_empty());

    EXPECT_EQ(laux.get_first(), 1);

    EXPECT_EQ(laux.get_last(), 2);

    EXPECT_EQ(list.size(), 3);

    EXPECT_EQ(list.get_first(), 1);

    EXPECT_EQ(list.get_last(), 2);

  }


  {                                // by move

    DynDlist<int> laux, list;

    laux.insert(2);

    list.append(move(laux));


    EXPECT_TRUE(laux.is_empty());

    EXPECT_FALSE(list.is_empty());

    EXPECT_EQ(list.get_first(), 2);

    EXPECT_EQ(list.get_last(), 2);

    EXPECT_TRUE(list.is_unitarian());

    EXPECT_TRUE(list.is_unitarian_or_empty());


    laux.insert(1);

    list.insert(move(laux));

    EXPECT_TRUE(laux.is_empty());

    EXPECT_EQ(list.size(), 2);

    EXPECT_EQ(list.get_first(), 1);

    EXPECT_EQ(list.get_last(), 2);

  }

}


TEST_F(List_of_10_items, copy_and_assignment)

{

  {                    // copy constructor

    auto tmp = list10;


    EXPECT_EQ(tmp.size(), list10.size());

    EXPECT_EQ(tmp.size(), 10);


    auto it1 = list10.get_it();

    auto it2 = tmp.get_it();

    for (; it1.has_curr() and it2.has_curr(); it1.next(), it2.next())

      ASSERT_EQ(it1.get_curr(), it2.get_curr());


    EXPECT_FALSE(it1.has_curr());

    EXPECT_FALSE(it2.has_curr());

  }


  EXPECT_FALSE(list10.is_empty());


  {                // move constructor

    auto tmp = move(list10);


    EXPECT_TRUE(list10.is_empty());

    EXPECT_EQ(list10.size(), 0);

    EXPECT_EQ(tmp.size(), 10);

    int i = 1;

    for (auto it = tmp.get_it(); it.has_curr(); it.next(), ++i)

      ASSERT_EQ(it.get_curr(), i);

    EXPECT_EQ(i, 11);

    list10.swap(tmp);

  }


  EXPECT_FALSE(list10.is_empty());

  DynDlist<int> aux;

  aux = list10;

  EXPECT_EQ(aux.size(), 10);

  int i = 1;

  for (auto it = aux.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);


  aux.empty();

  EXPECT_TRUE(aux.is_empty());


  aux = move(list10);

  EXPECT_TRUE(list10.is_empty());

  EXPECT_EQ(aux.size(), 10);


  i = 1;

  for (auto it = aux.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);


  list10 = move(aux);


  EXPECT_TRUE(aux.is_empty());

  EXPECT_EQ(list10.size(), 10);

  i = 1;

  for (auto it = list10.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);

}


TEST_F(List_of_25_items, Basic_operations)

{

  EXPECT_EQ(list25.get_first(), 1);

  EXPECT_EQ(list25.get_last(), 25);

  EXPECT_EQ(list25.size(), 25);

  EXPECT_FALSE(list25.is_empty());

  EXPECT_FALSE(list25.is_unitarian());

  EXPECT_FALSE(list25.is_unitarian_or_empty());

}


TEST_F(List_of_25_items, Iterator_operations)

{

  list25.for_each([] (auto i) { cout << i << " "; }); cout << endl;

  int i = 1;

  auto it = list25.get_it();

  for (; it.has_curr(); it.next(), ++i)

    {

      EXPECT_EQ(it.get_curr(), i);

      EXPECT_EQ(it.get_pos(), i - 1);

    }

  EXPECT_EQ(i, 26);


  i = 25;

  it.reset_last();

  for (; it.has_curr(); it.prev(), --i)

    {

      EXPECT_EQ(it.get_curr(), i);

      EXPECT_EQ(it.get_pos(), i - 1);

    }

  EXPECT_EQ(i, 0);

}


TEST_F(List_of_25_items, Split_and_concat)

{

  DynDlist<int> l, r;

  list25.split(l, r);


  EXPECT_TRUE(list25.is_empty());

  EXPECT_EQ(l.size(), 13);

  EXPECT_EQ(r.size(), 12);

  EXPECT_EQ(l.get_first(), 1);

  EXPECT_EQ(l.get_last(), 13);

  EXPECT_EQ(r.get_first(), 14);

  EXPECT_EQ(r.get_last(), 25);


  int i = 1;

  for (auto it = l.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  for (auto it = r.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  list25.append(r);

  list25.insert(l);

  i = 1;

  for (auto it = l.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, swap)

{

  DynDlist<int> laux;

  laux.swap(list25);


  EXPECT_TRUE(list25.is_empty());

  EXPECT_EQ(list25.size(), 0);

  EXPECT_FALSE(laux.is_empty());


  int i = 1;

  for (auto it = laux.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, reverse)

{

  list25.reverse();

  int i = 25;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), --i)

    EXPECT_EQ(it.get_curr(), i);


  list25.reverse();


  i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  DynDlist<int> l, r;

  list25.split(l, r);


  EXPECT_TRUE(list25.is_empty());


  l.reverse();

  r.reverse();

  list25.insert(l);

  list25.insert(r);


  list25.reverse();

  i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, rotate_left)

{

  list25.rotate_left(3);


  {

    auto it = list25.get_it();

    for (int i = 0, n = 4; i < 3; ++i, ++n, it.next())

      EXPECT_EQ(it.get_curr(), n);

  }


  list25.rotate_left(22);

  int i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, rotate_right)

{

  list25.rotate_right(3);


  {

    auto it = list25.get_it();

    for (int i = 0, n = 23; i < 3; ++i, ++n, it.next())

      EXPECT_EQ(it.get_curr(), n);

  }


  list25.rotate_right(22);

  int i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, append_and_insert_by_moving)

{

  DynDlist<int> ll = { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9 };

  DynDlist<int> lg = { 26, 27, 28, 29, 30, 31, 32, 33, 34, 35 };


  ll.reverse();


  list25.insert(std::move(ll));

  list25.append(std::move(lg));


  EXPECT_TRUE(ll.is_empty());

  EXPECT_TRUE(lg.is_empty());


  int i = -9;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST(DynDlist, traverse_on_empty_container)

{

  DynDlist<int> m;

  size_t n = 0;

  auto ret = m.traverse([&n] (int) { ++n; return true; });

  EXPECT_TRUE(ret);

  EXPECT_EQ(n, 0);

}


TEST_F(List_of_25_items, traverse)

{

  EXPECT_TRUE(list25.size() > 0);

  EXPECT_EQ(list25.size(), n);

  int N = 0;

  auto ret = list25.traverse([&N, this] (int i) { ++N; return i < n/2; });

  EXPECT_FALSE(ret);

  EXPECT_EQ(N, n/2);

}


TEST(DynDlist, RemoveAndEraseByReference)

{

  DynDlist<int> list;

  for (int i = 1; i <= 4; ++i)

    list.append(i);


  int &middle = list[2];

  list.remove(middle);

  ASSERT_EQ(list.size(), 3u);

  int expected_after_remove[] = {1, 2, 4};

  int idx = 0;

  for (auto it = list.get_it(); it.has_curr(); it.next(), ++idx)

    EXPECT_EQ(it.get_curr(), expected_after_remove[idx]);


  int &first = list.get_first();

  list.erase(first);

  EXPECT_EQ(list.size(), 2u);

  EXPECT_EQ(list.get_first(), 2);

  EXPECT_EQ(list.get_last(), 4);

}


TEST(DynDlist, OperatorIndexEnforcesBounds)

{

  DynDlist<int> list;

  for (int i = 0; i < 5; ++i)

    list.append(i);


  list[2] = 99;

  EXPECT_EQ(list[2], 99);


  const DynDlist<int> &clist = list;

  EXPECT_EQ(clist[0], 0);


  EXPECT_THROW(list[5], std::out_of_range);

  EXPECT_THROW(list[10], std::out_of_range);


  DynDlist<int> empty;

  EXPECT_THROW(empty[0], std::out_of_range);

}


TEST_F(List_of_10_items, ConstReverseReturnsIndependentCopy)

{

  const DynDlist<int> &cref = list10;

  auto reversed = cref.reverse();


  int expected_desc = 10;

  for (auto it = reversed.get_it(); it.has_curr(); it.next(), --expected_desc)

    EXPECT_EQ(it.get_curr(), expected_desc);

  EXPECT_EQ(expected_desc, 0);


  int expected_orig = 1;

  for (auto it = cref.get_it(); it.has_curr(); it.next(), ++expected_orig)

    EXPECT_EQ(it.get_curr(), expected_orig);

  EXPECT_EQ(expected_orig, 11);


  auto reversed_alias = cref.rev();

  int expected_desc_alias = 10;

  for (auto it = reversed_alias.get_it(); it.has_curr(); it.next(), --expected_desc_alias)

    EXPECT_EQ(it.get_curr(), expected_desc_alias);

  EXPECT_EQ(expected_desc_alias, 0);

}


TEST(DynDlist, IteratorInsertAndAppendOperations)

{

  DynDlist<int> list = {1, 3};

  auto it = list.get_it();

  ASSERT_TRUE(it.has_curr());


  it.insert(2);

  int expected_after_insert[] = {1, 2, 3};

  int idx = 0;

  for (auto iter = list.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_insert[idx]);


  it.reset_first();

  it.append(0);

  int expected_after_append[] = {0, 1, 2, 3};

  idx = 0;

  for (auto iter = list.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_append[idx]);


  auto at_end = list.get_it();

  at_end.end();

  EXPECT_THROW(at_end.insert(42), std::overflow_error);

  EXPECT_THROW(at_end.append(42), std::overflow_error);

}


TEST(DynDlist, IteratorListOperations)

{

  DynDlist<int> base = {1, 4};

  DynDlist<int> middle = {2, 3};

  DynDlist<int> head = {-1, 0};


  auto it = base.get_it();

  ASSERT_TRUE(it.has_curr());

  it.insert_list(middle);

  EXPECT_TRUE(middle.is_empty());


  int expected_after_insert_list[] = {1, 2, 3, 4};

  int idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_insert_list[idx]);


  it.reset_first();

  it.append_list(head);

  EXPECT_TRUE(head.is_empty());


  int expected_after_append_list[] = {-1, 0, 1, 2, 3, 4};

  idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_append_list[idx]);

}


TEST(DynDlist, IteratorListOperationsRequireCurrent)

{

  DynDlist<int> base = {1, 2, 3};

  DynDlist<int> extra = {4, 5};


  auto it = base.get_it();

  it.end();

  EXPECT_THROW(it.insert_list(extra), std::overflow_error);

  EXPECT_THROW(it.append_list(extra), std::overflow_error);


  // ni la lista base ni la extra deberían alterarse tras los errores

  int expected_base[] = {1, 2, 3};

  int idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_base[idx]);

  EXPECT_FALSE(extra.is_empty());

  EXPECT_EQ(extra.size(), 2u);

}


TEST(DynDlist, SplitRequiresEmptyDestination)

{

  DynDlist<int> source = {1, 2, 3};

  DynDlist<int> left;

  DynDlist<int> right;


  left.append(42);

  EXPECT_THROW(source.split(left, right), std::domain_error);


  left.empty();

  right.append(99);

  EXPECT_THROW(source.split(left, right), std::domain_error);

}


TEST(DynDlist, StackAndQueueAliases)

{

  DynDlist<int> list;

  list.push(3);

  list.push(2);

  list.push(1);


  EXPECT_EQ(list.top(), 1);

  EXPECT_EQ(list.pop(), 1);

  EXPECT_EQ(list.top(), 2);


  list.put(99);

  EXPECT_EQ(list.rear(), 99);

  EXPECT_EQ(list.front(), 2);

  EXPECT_EQ(list.get(), 2);

  EXPECT_EQ(list.front(), 3);


  list.pop();

  list.pop();

  EXPECT_TRUE(list.is_empty());

  EXPECT_THROW(list.pop(), std::underflow_error);

}


Aleph::Dlink::is_unitarian_or_empty
constexpr bool is_unitarian_or_empty() const noexcept
Return true if this (as header node) has zero or one element.
Definition dlink.H:252

Aleph::Dlink::is_empty
constexpr bool is_empty() const noexcept
Return true if this (as header node) is empty.
Definition dlink.H:246

Aleph::Dlink::is_unitarian
constexpr bool is_unitarian() const noexcept
Return true if this (as header node) has exactly one element.
Definition dlink.H:249

Aleph::Dlink::rotate_left
void rotate_left(size_t n)
Rotate to left the list n positions.
Definition dlink.H:855

Aleph::DynDlist
Dynamic doubly linked list with O(1) size and bidirectional access.
Definition tpl_dynDlist.H:124

Aleph::DynDlist::get_last
T & get_last() const
Return a modifiable reference to last item in the list.
Definition tpl_dynDlist.H:305

Aleph::DynDlist::size
const size_t & size() const noexcept
Return the number of elements (constant time)
Definition tpl_dynDlist.H:139

Aleph::DynDlist::reverse
DynDlist & reverse() noexcept
Definition tpl_dynDlist.H:809

Aleph::DynDlist::front
T & front()
If this was treated as a queue, the it returns the most oldlest inserted item.
Definition tpl_dynDlist.H:379

Aleph::DynDlist::pop
T pop()
Definition tpl_dynDlist.H:388

Aleph::DynDlist::push
T & push(const T &item)
Definition tpl_dynDlist.H:382

Aleph::DynDlist::remove
void remove(T &data) noexcept
Assuming that data is a reference to the item in the list, it removes the item.
Definition tpl_dynDlist.H:406

Aleph::DynDlist::put
T & put(const T &item)
Definition tpl_dynDlist.H:365

Aleph::DynDlist::empty
void empty() noexcept
Empty the list.
Definition tpl_dynDlist.H:155

Aleph::DynDlist::append
T & append(const T &item)
Append a copied item at the end of the list.
Definition tpl_dynDlist.H:214

Aleph::DynDlist::rear
T & rear()
If this was treated as a queue, the it returns the most recently inserted item.
Definition tpl_dynDlist.H:375

Aleph::DynDlist::split
void split(DynDlist &l, DynDlist &r)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition tpl_dynDlist.H:476

Aleph::DynDlist::get_first
T & get_first() const
Return a modifiable reference to first item in the list.
Definition tpl_dynDlist.H:297

Aleph::DynDlist::erase
void erase(T &data) noexcept
Definition tpl_dynDlist.H:415

Aleph::DynDlist::insert
T & insert(const T &item)
Insert a copy of item at the beginning of the list.
Definition tpl_dynDlist.H:192

Aleph::DynDlist::get
T get()
Definition tpl_dynDlist.H:371

Aleph::DynDlist::remove_first
T remove_first()
Remove the first item of the list; return a copy of removed item.
Definition tpl_dynDlist.H:345

Aleph::DynDlist::top
T & top() const
Definition tpl_dynDlist.H:391

Aleph::DynList::insert
T & insert(const T &item)
Insert a new item by copy.
Definition htlist.H:1502

Aleph::DynList::append
T & append(const T &item)
Append a new item by copy.
Definition htlist.H:1562

Aleph::DynList::get_last
T & get_last() const
Return the last item of the list.
Definition htlist.H:1663

Aleph::DynList::get_first
T & get_first() const
Return the first item of the list.
Definition htlist.H:1675

Aleph::DynList::rev
DynList & rev() noexcept
Definition htlist.H:1769

Aleph::DynList::reverse
DynList & reverse() noexcept
Definition htlist.H:1763

Aleph::DynList::swap
DynList & swap(DynList &l) noexcept
Swap this with l.
Definition htlist.H:1448

Aleph::HTList::is_empty
constexpr bool is_empty() const noexcept
Return true if list is empty.
Definition htlist.H:523

Aleph::HTList::rotate_left
void rotate_left(size_t n)
Rotate to left the list n positions.
Definition htlist.H:1359

Aleph::HTList::split
size_t split(HTList &l, HTList &r) noexcept
Definition htlist.H:977

Aleph::HTList::size
size_t size() const noexcept
Count the number of elements of the list.
Definition htlist.H:1319

LocateFunctions::get_it
auto get_it() const
Return a properly initialized iterator positioned at the first item on the container.
Definition ah-dry.H:190

StlAlephIterator::end
iterator end() noexcept
Return an STL-compatible end iterator.
Definition ah-iterator.H:267

TEST
#define TEST(name)
Definition disjoint_sparse_table_test.cc:95

TEST_F
TEST_F(List_of_10_items, copy_and_assignment)
Definition dyndlist.cc:158

Declare_list_n_items
#define Declare_list_n_items(num)
Definition dyndlist.cc:46

N
#define N
Definition fib.C:294

Aleph
Main namespace for Aleph-w library functions.
Definition ah-arena.H:89

Aleph::reverse
void reverse(Itor beg, Itor end)
Reverse elements in a range.
Definition ahAlgo.H:1094

Aleph::swap
T & swap(T &t1, T &t2)
Generic swap using object's swap method.
Definition ahTypes.H:121

Aleph::traverse
bool traverse(Node *root, Op op)
Definition tpl_binNodeUtils.H:2879

Aleph::rotate_left
void rotate_left(T *ptr, const size_t n, size_t m) noexcept
Rotate array elements left by m positions.
Definition array_utils.H:180

Aleph::rotate_right
void rotate_right(T *ptr, const size_t n, size_t m) noexcept
Rotate array elements right by m positions.
Definition array_utils.H:213

Aleph::maps
DynList< T > maps(const C &c, Op op)
Classic map operation.
Definition ahFunctional.H:693

std
STL namespace.

GenericTraverse::traverse
bool traverse(Operation &operation) noexcept(traverse_is_noexcept< Operation >())
Traverse the container via its iterator and performs a conditioned operation on each item.
Definition ah-dry.H:95

List_of_10_items
Definition dyndlist.cc:63

List_of_25_items
Definition dyndlist.cc:62

tpl_dynDlist.H
Dynamic doubly linked list implementation.

l
DynList< int > l
Definition tree-node-common.H:69