d6/d1a/memarray_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_memArray.H>

# include <htlist.H>

# include <memory>


using namespace std;

using namespace testing;

using namespace Aleph;


bool is_power_of_two(size_t x)

{

  return ((x != 0) && !(x & (x - 1))) != 0;

}


struct Default_MemArray : public Test

{

  const size_t n = 64;

  MemArray<int> m = {n};

};


struct MemArray_with_30_items : public Test

{

  MemArray<int> m;


  MemArray_with_30_items()

  {

    for (size_t i = 0; i < 30; ++i)

      m.append(i);

  }


};


TEST(MemArray, Basic_initialization)

{

  {

    MemArray<int> m1;

    EXPECT_TRUE(is_power_of_two(m1.capacity()));

    EXPECT_EQ(m1.size(), 0);

    EXPECT_TRUE(m1.is_empty());

    EXPECT_THROW(m1.get(), underflow_error);

  }


  {

    MemArray<int> m1(32);

    EXPECT_TRUE(is_power_of_two(m1.capacity()));

    EXPECT_EQ(m1.size(), 0);

    EXPECT_TRUE(m1.is_empty());

    EXPECT_THROW(m1.get(), underflow_error);


    MemArray<int> m2(31);

    MemArray<int> m3(17);

    EXPECT_TRUE(is_power_of_two(m2.capacity()));

    EXPECT_TRUE(m2.is_empty());

    EXPECT_TRUE(m3.is_empty());

    EXPECT_EQ(m2.size(), 0);

    EXPECT_EQ(m3.size(), 0);

    EXPECT_EQ(m1.capacity(), m2.capacity());

    EXPECT_EQ(m1.capacity(), m3.capacity());

  }


  {

    MemArray<int> m1(512);

    EXPECT_TRUE(is_power_of_two(m1.capacity()));

    EXPECT_EQ(m1.size(), 0);

    EXPECT_TRUE(m1.is_empty());

    EXPECT_THROW(m1.get(), underflow_error);


    MemArray<int> m2(257);

    MemArray<int> m3(316);

    EXPECT_TRUE(is_power_of_two(m2.capacity()));

    EXPECT_TRUE(m2.is_empty());

    EXPECT_TRUE(m3.is_empty());

    EXPECT_EQ(m2.size(), 0);

    EXPECT_EQ(m3.size(), 0);

    EXPECT_EQ(m1.capacity(), m2.capacity());

    EXPECT_EQ(m1.capacity(), m3.capacity());

  }


  {

    MemArray<int> m1(4096);

    EXPECT_TRUE(is_power_of_two(m1.capacity()));

    EXPECT_EQ(m1.size(), 0);

    EXPECT_TRUE(m1.is_empty());

    EXPECT_THROW(m1.get(), underflow_error);


    MemArray<int> m2(2049);

    MemArray<int> m3(3000);

    EXPECT_TRUE(is_power_of_two(m2.capacity()));

    EXPECT_TRUE(m2.is_empty());

    EXPECT_TRUE(m3.is_empty());

    EXPECT_EQ(m2.size(), 0);

    EXPECT_EQ(m3.size(), 0);

    EXPECT_EQ(m1.capacity(), m2.capacity());

    EXPECT_EQ(m1.capacity(), m3.capacity());

  }

}


TEST_F(Default_MemArray, growing_in_2_powers)

{

  const size_t n = m.capacity();

  for (size_t i = 0; i < n; ++i)

    m.append(i);


  EXPECT_EQ(m.size(), n);

  EXPECT_EQ(m.capacity(), n);


  m.append(n); // this append would cause expansion

  EXPECT_EQ(m.capacity(), 2 * n);

  EXPECT_EQ(m.size(), n + 1);

  EXPECT_EQ(m.get_first(), 0);

  EXPECT_EQ(m.get_last(), n);


  // testing gap opening

  m.insert(-1);

  EXPECT_EQ(m.get_first(), -1);

  EXPECT_EQ(m.get_last(), n);


  EXPECT_THROW(m[m.size()], out_of_range);

  EXPECT_THROW(m[m.capacity()], out_of_range);


  { // Testing operator [] in read mode

    int k = -1;

    for (size_t i = 0; i < m.size(); ++i, ++k)

      EXPECT_EQ(m[i], k);

    EXPECT_EQ(k, n + 1);

  }


  { // Testing operator [] in write mode

    for (size_t i = 0; i < m.size(); ++i)

      m[i]++;


    int k = 0;

    for (size_t i = 0; i < m.size(); ++i, ++k)

      EXPECT_EQ(m[i], k);

    EXPECT_EQ(k, n + 2);

  }

}


TEST_F(Default_MemArray, putn)

{

  const size_t dim = m.capacity();


  m.putn(dim + 1); // This will cause expansion


  EXPECT_EQ(m.capacity(), 2 * dim); // Verify expansion

  EXPECT_FALSE(m.is_empty());

  EXPECT_EQ(m.size(), dim + 1);


  for (size_t i = 0; i < m.size(); ++i)

    {

      EXPECT_NO_THROW(m[i]);

      m[i] = i;

    }


  EXPECT_THROW(m[m.size()], out_of_range);

  EXPECT_THROW(m.get(m.size() + 1), underflow_error);


  size_t k = 0;

  EXPECT_NE(m.size(), k);

  for (size_t i = 0; i < m.size(); ++i, ++k)

    EXPECT_EQ(m[i], i);

  EXPECT_EQ(k, m.size()); // TEST that loop has been executed


  const size_t curr_cap = m.capacity();

  const size_t avail = m.capacity() - m.size();

  m.putn(avail); // this shouldn't cause expansion


  EXPECT_EQ(m.capacity(), curr_cap);

  EXPECT_EQ(m.size(), m.capacity());


  int item;

  EXPECT_NO_THROW(item = m.get(m.size())); // it must take out all items


  EXPECT_EQ(item, 0);

  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);

}


TEST(MemArrayMoveOnly, AppendAndRemoveUniquePtr)

{

  MemArray<std::unique_ptr<int>> m;


  auto p1 = std::make_unique<int>(5);

  auto p2 = std::make_unique<int>(7);


  m.append(std::move(p1));

  m.append(std::move(p2));


  ASSERT_EQ(m.size(), 2u);

  EXPECT_EQ(*m[0], 5);

  EXPECT_EQ(*m[1], 7);


  auto last = m.remove_last();

  EXPECT_EQ(*last, 7);

  EXPECT_EQ(m.size(), 1u);


  auto first = m.remove_first();

  EXPECT_EQ(*first, 5);

  EXPECT_TRUE(m.is_empty());

}


TEST_F(Default_MemArray, access_operator)

{

  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);

  EXPECT_NE(m.capacity(), 0);


  const size_t cap1 = m.capacity();


  // Test invalid accesses without insertion neither expansion

  size_t k = 0;

  for (size_t i = 0; i < m.capacity(); ++i, ++k)

    EXPECT_THROW(m[i], out_of_range);

  EXPECT_EQ(k, m.capacity());

  EXPECT_EQ(m.capacity(), cap1); // capacity has not changed

  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);


  // Insert until capacity (no expansion)

  k = 0;

  for (size_t i = 0; i < m.capacity(); ++i, ++k)

    m.append(i);

  EXPECT_EQ(k, m.capacity());

  EXPECT_EQ(m.size(), m.capacity());


  // Test that item were inserted

  k = 0;

  for (size_t i = 0; i < m.capacity(); ++i, ++k)

    {

      EXPECT_NO_THROW(m[i]);

      EXPECT_EQ(m[i], i);

    }

  EXPECT_EQ(k, m.capacity());


  // Now we cause an expansion

  k = 0;

  for (size_t i = m.size(); i < 2 * cap1; ++i, ++k)

    m.append(i);


  EXPECT_EQ(k, cap1);

  EXPECT_EQ(m.capacity(), 2 * cap1);

  EXPECT_EQ(m.size(), 2 * cap1);


  k = 0;

  for (size_t i = 0; i < m.size(); ++i, ++k)

    {

      EXPECT_NO_THROW(m[i]);

      EXPECT_EQ(m[i], i);

    }

  EXPECT_EQ(k, m.capacity());

}


TEST_F(Default_MemArray, reserve)

{

  const size_t cap = m.capacity();

  EXPECT_TRUE(m.is_empty());

  EXPECT_NE(m.capacity(), 0);

  EXPECT_EQ(m.size(), 0);


  m.reserve(2 * cap + 1); // this should expand to 4*cap

  EXPECT_EQ(m.capacity(), 4 * cap);

}


TEST_F(MemArray_with_30_items, copy_and_assigment)

{

  EXPECT_FALSE(m.is_empty());

  EXPECT_EQ(m.size(), 30);

  EXPECT_EQ(m.capacity(), 32);

  size_t k = 0;

  for (size_t i = 0; i < m.size(); ++i, ++k)

    EXPECT_EQ(m[i], i);

  EXPECT_EQ(k, m.size());


  { // Copy constructor

    MemArray<int> aux = m;

    EXPECT_FALSE(aux.is_empty());

    EXPECT_EQ(aux.size(), 30);

    EXPECT_EQ(aux.capacity(), 32);

    size_t k = 0;

    for (size_t i = 0; i < m.size(); ++i, ++k)

      EXPECT_EQ(aux[i], i);

    EXPECT_EQ(k, m.size());

    EXPECT_NE(m.get_ptr(), aux.get_ptr());

  }


  { // move constructor

    auto ptr = m.get_ptr();

    MemArray<int> aux = move(m);

    EXPECT_EQ(aux.get_ptr(), ptr);

    EXPECT_FALSE(aux.is_empty());

    EXPECT_EQ(aux.size(), 30);

    EXPECT_EQ(aux.capacity(), 32);

    EXPECT_TRUE(m.is_empty());

    EXPECT_EQ(m.size(), 0);

    EXPECT_EQ(m.capacity(), 0);

    EXPECT_EQ(m.get_ptr(), nullptr); // array of zero must be nullptr

    size_t k = 0;

    for (size_t i = 0; i < m.size(); ++i, ++k)

      EXPECT_EQ(aux[i], i);

    EXPECT_EQ(k, m.size());

    EXPECT_NE(m.get_ptr(), aux.get_ptr());


    m.swap(aux); // restore m to previous initialized state

    EXPECT_EQ(m.get_ptr(), ptr);

    EXPECT_TRUE(aux.is_empty());

    EXPECT_EQ(aux.size(), 0);

    EXPECT_EQ(aux.capacity(), 0);

    EXPECT_FALSE(m.is_empty());

    EXPECT_EQ(m.size(), 30);

    EXPECT_EQ(m.capacity(), 32);

    k = 0;

    for (size_t i = 0; i < m.size(); ++i, ++k)

      EXPECT_EQ(m[i], i);

    EXPECT_EQ(k, m.size());

  }


  // copy assigment

  MemArray<int> aux;

  EXPECT_TRUE(aux.is_empty());

  EXPECT_EQ(aux.size(), 0);

  EXPECT_NE(aux.capacity(), 0);

  EXPECT_NE(aux.get_ptr(), nullptr);


  aux = m;

  EXPECT_FALSE(aux.is_empty());

  EXPECT_NE(m.size(), 0);

  EXPECT_EQ(aux.size(), m.size());

  EXPECT_EQ(aux.capacity(), m.capacity());

  EXPECT_FALSE(m.is_empty());

  EXPECT_NE(m.size(), 0);

  EXPECT_NE(m.capacity(), 0);

  EXPECT_NE(m.get_ptr(), aux.get_ptr()); // array of zero must be nullptr

  k = 0;

  for (size_t i = 0; i < m.size(); ++i, ++k)

    EXPECT_EQ(aux[i], m[i]);

  EXPECT_EQ(k, m.size());


  // TODO move assigment

}


TEST(MemArray, zero_capacity)

{

  MemArray<int> m(0);

  EXPECT_NE(m.capacity(), 0);

  EXPECT_EQ(m.size(), 0);

  EXPECT_NE(m.get_ptr(), nullptr);

  EXPECT_TRUE(m.is_empty());

}


TEST(MemArray, insertion_with_rvalues)

{

  MemArray<DynList<int>> m;

  EXPECT_EQ(m.size(), 0);

  EXPECT_TRUE(m.is_empty());


  size_t N = 0;

  for (size_t i = 0; i < 10; ++i)

    {

      DynList<int> l;

      EXPECT_TRUE(l.is_empty());

      for (size_t k = 0; k < 10; ++k, ++N)

        l.append(N);

      EXPECT_FALSE(l.is_empty());

      m.insert(move(l));

      EXPECT_TRUE(l.is_empty());

    }


  size_t n = 0;

  for (long i = 9; i >= 0; --i) // descending for matching values of N

    {

      const DynList<int> &l = m[i];

      EXPECT_FALSE(l.is_empty());

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

        EXPECT_EQ(it.get_curr(), n);

    }

}


TEST(MemArray, remove_with_rvalues)

{

  constexpr size_t num_items = 10;

  MemArray<DynList<int>> m;

  size_t N = 0;

  for (size_t i = 0; i < num_items; ++i)

    {

      DynList<int> l;

      EXPECT_TRUE(l.is_empty());

      for (size_t k = 0; k < num_items; ++k, ++N)

        l.insert(N);

      EXPECT_FALSE(l.is_empty());

      m.insert(move(l));

      EXPECT_TRUE(l.is_empty());

    }


  size_t n = N - 1;

  for (size_t i = 0; i < num_items; ++i)

    {

      DynList<int> l = m.remove_first();

      auto it = l.get_it();

      for (size_t k = 0; k < 10; ++k, it.next(), --n)

        EXPECT_EQ(it.get_curr(), n);

      assert(num_items - i < m.capacity()); // hard assert. Better leave it!

      EXPECT_TRUE(m(num_items - i - 1).is_empty()); // verify moving

    }

}


TEST_F(Default_MemArray, contraction)

{

  for (size_t i = 0; i < n; ++i)

    m.append(i);


  EXPECT_EQ(m.capacity(), n);

  EXPECT_EQ(m.capacity(), m.size());


  size_t N = m.capacity();

  for (size_t i = 0; i < n; ++i)

    {

      EXPECT_EQ(m.remove_last(), n - i - 1);

      if (m.size() == N / 4 - 1 and m.size() > m.contract_threshold)

        {

          N /= 2;

          EXPECT_EQ(m.capacity(), N); // valid if contraction was done!

        }

    }

}


TEST_F(Default_MemArray, remove_on_empty)

{

  EXPECT_THROW(m.remove_last(), underflow_error);

  EXPECT_THROW(m.remove_first(), underflow_error);

  EXPECT_THROW(m.get(), underflow_error);

  EXPECT_THROW(m.get(2), underflow_error);

}


TEST(MemArray, as_stack)

{

  MemArray<int> m;


  EXPECT_THROW(m.top(), underflow_error);


  for (size_t i = 0; i < 100; ++i)

    EXPECT_EQ(m.push(i), i);


  for (size_t i = 100; i > 0; --i)

    EXPECT_EQ(m.pop(), i - 1);


  EXPECT_TRUE(m.is_empty());

  ASSERT_EQ(m.size(), 0);

  EXPECT_THROW(m.top(), underflow_error);

  EXPECT_THROW(m.pop(), underflow_error);

}


TEST(MemArray, Iterator_on_empty_container)

{

  MemArray<int> empty_m;

  MemArray<int>::Iterator it = empty_m;

  EXPECT_FALSE(it.has_curr());

  EXPECT_THROW(it.get_curr(), overflow_error);

  EXPECT_THROW(it.next(), overflow_error);

  EXPECT_THROW(it.prev(), underflow_error);

  it.reset();

  EXPECT_FALSE(it.has_curr());

  EXPECT_THROW(it.get_curr(), overflow_error);

  EXPECT_THROW(it.next(), overflow_error);

  EXPECT_THROW(it.prev(), underflow_error);

  it.reset_last();

  EXPECT_FALSE(it.has_curr());

  EXPECT_THROW(it.get_curr(), underflow_error);

  EXPECT_THROW(it.next(), overflow_error);

  EXPECT_THROW(it.prev(), underflow_error);

}


TEST_F(Default_MemArray, Iterator)

{

  int i = 0;

  for (MemArray<int>::Iterator it = m; it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  MemArray<int>::Iterator it = m;

  it.reset_last();

  i = n - 1;

  for (MemArray<int>::Iterator it = m; it.has_curr(); it.prev(), --i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST(MemArray, traverse_on_empty_container)

{

  MemArray<int> m;

  size_t n = 0;

  auto ret = m.traverse([&n](int)

                        {

                          ++n;

                          return true;

                        });

  EXPECT_TRUE(ret);

  EXPECT_EQ(n, 0);

}


TEST_F(Default_MemArray, clear)

{

  const size_t cap = m.capacity();


  // Test 1: clear on empty

  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);


  static_assert(noexcept(m.clear()), "clear() must be noexcept");

  m.clear();


  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);

  EXPECT_EQ(m.capacity(), cap);

  EXPECT_NE(m.get_ptr(), nullptr);


  // Test 2: clear on populated

  for (size_t i = 0; i < 10; ++i)

    m.append(i);


  EXPECT_FALSE(m.is_empty());

  EXPECT_EQ(m.size(), 10);

  const size_t cap_before = m.capacity();

  const int* ptr_before = m.get_ptr();


  m.clear();


  EXPECT_TRUE(m.is_empty());

  EXPECT_EQ(m.size(), 0);

  EXPECT_EQ(m.capacity(), cap_before);

  EXPECT_EQ(m.get_ptr(), ptr_before);


  // Verify it can be reused

  m.append(100);

  EXPECT_EQ(m.size(), 1);

  EXPECT_EQ(m[0], 100);

}


TEST_F(Default_MemArray, traverse)

{

  int N = 0;

  auto ret = m.traverse([&N, this](int i)

                        {

                          ++N;

                          return i == n / 2;

                        }); // m is empty

  EXPECT_TRUE(ret);

  EXPECT_EQ(N, 0);


  for (size_t i = 0; i < n; ++i)

    m.append(i);


  EXPECT_EQ(N, 0);

  EXPECT_TRUE(m.size() > 0);

  EXPECT_EQ(m.size(), n);

  ret = m.traverse([&N, this](int i)

                   {

                     ++N;

                     return i < n / 2;

                   });

  EXPECT_FALSE(ret);

  EXPECT_EQ(N, n / 2 + 1);

}


Aleph::Array_Iterator::get_curr
T & get_curr() const
Get the current item with bounds checking.
Definition array_it.H:245

Aleph::Array_Iterator::reset_last
void reset_last() noexcept
Reset the iterator to the last item.
Definition array_it.H:307

Aleph::Array_Iterator::reset
void reset() noexcept
Reset the iterator to the first item.
Definition array_it.H:297

Aleph::Array_Iterator::prev
void prev()
Move to the previous item with bounds checking.
Definition array_it.H:289

Aleph::Array_Iterator::next
void next()
Advance to the next item with bounds checking.
Definition array_it.H:269

Aleph::Array_Iterator::has_curr
bool has_curr() const noexcept
Check if there is a current valid item.
Definition array_it.H:219

Aleph::DynList
Dynamic singly linked list with functional programming support.
Definition htlist.H:1155

Aleph::DynList::insert
T & insert(const T &item)
Definition htlist.H:1220

Aleph::DynList::append
T & append(const T &item)
Definition htlist.H:1271

Aleph::HTList::is_empty
constexpr bool is_empty() const noexcept
Definition htlist.H:419

Aleph::MemArray
Simple, scalable and fast dynamic array.
Definition tpl_memArray.H:135

Aleph::MemArray::size
size_t size() const noexcept
Return the number of elements.
Definition tpl_memArray.H:267

Aleph::MemArray::append
T & append(const T &item)
Definition tpl_memArray.H:480

Aleph::MemArray::get_ptr
T * get_ptr() const noexcept
Return the current base of array.
Definition tpl_memArray.H:148

Aleph::MemArray::capacity
constexpr size_t capacity() const noexcept
The type of element of array.
Definition tpl_memArray.H:261

Aleph::MemArray::is_empty
bool is_empty() const noexcept
Return true is the array is empty.
Definition tpl_memArray.H:273

Aleph::ODhashTable::swap
void swap(ODhashTable &other) noexcept
Definition tpl_odhash.H:420

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

OhashCommon::append
Key * append(const Key &key)
Alias for insert() (copy version).
Definition hashDry.H:389

OhashCommon::size
constexpr size_t size() const noexcept
Returns the number of entries in the table.
Definition hashDry.H:619

OhashCommon::capacity
constexpr size_t capacity() const noexcept
Returns the current capacity of the table.
Definition hashDry.H:629

OhashCommon::clear
void clear()
Empties the container.
Definition hashDry.H:614

OhashCommon::is_empty
constexpr bool is_empty() const noexcept
Checks if the table is empty.
Definition hashDry.H:624

OhashCommon::insert
Key * insert(const Key &key)
Inserts a key into the hash table (copy version).
Definition hashDry.H:203

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

N
#define N
Definition fib.C:294

dim
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_dim_function > > dim(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4052

htlist.H
Singly linked list implementations with head-tail access.

is_power_of_two
bool is_power_of_two(size_t x)
Definition memarray.cc:48

TEST_F
TEST_F(Default_MemArray, growing_in_2_powers)
Definition memarray.cc:134

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

Aleph::and
and
Check uniqueness with explicit hash + equality functors.
Definition ahFunctional.H:2594

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

Aleph::divide_and_conquer_partition_dp
Divide_Conquer_DP_Result< Cost > divide_and_conquer_partition_dp(const size_t groups, const size_t n, Transition_Cost_Fn transition_cost, const Cost inf=dp_optimization_detail::default_inf< Cost >())
Optimize partition DP using divide-and-conquer optimization.
Definition DP_Optimizations.H:133

std
STL namespace.

Aleph::MemArray::Iterator
Simple iterator on elements of array.
Definition tpl_memArray.H:723

Default_MemArray
Definition memarray.cc:54

Default_MemArray::n
const size_t n
Definition memarray.cc:55

Default_MemArray::m
MemArray< int > m
Definition memarray.cc:56

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:97

MemArray_with_30_items
Definition memarray.cc:60

MemArray_with_30_items::m
MemArray< int > m
Definition memarray.cc:61

MemArray_with_30_items::MemArray_with_30_items
MemArray_with_30_items()
Definition memarray.cc:62

m
FooMap m(5, fst_unit_pair_hash, snd_unit_pair_hash)

Test
Dnode< int > Test
Definition testDnode.C:37

k
static int * k
Definition testOpBinTree.C:49

tpl_memArray.H
Simple, scalable, contiguous dynamic array.

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