#include <htlist.H>
Classes | |
class | Iterator |
Public Types | |
using | Item_Type = T |
The type of item. | |
using | Key_Type = T |
The type of item. | |
using | iterator = StlIterator< SetName > |
using | const_iterator = StlConstIterator< SetName > |
Public Member Functions | |
DynList & | swap (DynList &l) noexcept |
DynList () noexcept(std::is_nothrow_constructible< T >::value) | |
Initialize an empty list. | |
DynList (const DynList &l) | |
T & | insert (const T &item) |
T & | insert (T &&item) |
T & | push (const T &item) |
T & | push (T &&item) |
T & | put (const T &item) noexcept(noexcept(T(item))) |
T & | put (T &&item) noexcept(noexcept(std::forward< T >(item))) |
T & | append (const T &item) |
T & | append (T &&item) |
T | remove_ne () noexcept |
T | remove () |
T | remove_first_ne () noexcept |
T | remove_first () |
T | pop () |
T | get () |
T & | get_last_ne () const noexcept |
T & | get_first_ne () const noexcept |
T & | get_last () const |
T & | get_first () const |
T & | top () const |
void | empty () noexcept |
empty the list | |
DynList & | reverse () noexcept |
DynList & | rev () noexcept |
DynList | reverse () const |
DynList | rev () const |
template<class Equal = std::equal_to<T>> | |
T | remove_ne (Equal eq) noexcept |
template<class Equal = std::equal_to<T>> | |
T | remove (Equal eq) |
DynList (DynList &&l) noexcept | |
DynList & | operator= (const DynList &l) |
DynList & | operator= (DynList &&l) noexcept |
DynList & | append (DynList &&list) noexcept |
DynList & | insert (DynList &&list) noexcept |
DynList & | append (const DynList &list) noexcept(noexcept(DynList(list))) |
DynList & | insert (const DynList &list) noexcept(noexcept(DynList(list))) |
T & | get (const size_t &i) |
T & | operator[] (const size_t &i) |
void | reset () |
bool | is_empty () const noexcept |
bool | is_unitarian () const noexcept |
bool | is_unitarian_or_empty () const noexcept |
Slinknc * | get_head () const noexcept |
Slinknc * | get_tail () const noexcept |
HTList & | swap (HTList &l) noexcept |
Swap in constant time (very fast) 'this' elements with 'l' list elements Referenced by append(), insert(), reverse() and split_list(). More... | |
void | insert (Slinknc *link) noexcept |
void | insert (HTList &l) noexcept |
void | insert (Slinknc *link, HTList &list) noexcept |
void | append (Slinknc *link) noexcept |
void | append (HTList &l) noexcept |
void | put (Slinknc *link) noexcept |
void | concat (HTList &l) noexcept |
void | concat_list (HTList &l) noexcept |
Slinknc * | remove_head_ne () noexcept |
Slinknc * | remove_head () |
bool | remove (Slinknc *link) |
void | push (Slinknc *link) noexcept |
Slinknc * | top () |
size_t | split_list (HTList &l, HTList &r) noexcept |
size_t | split_list_ne (HTList &l, HTList &r) noexcept |
size_t | split (HTList &l, HTList &r) noexcept |
size_t | reverse_list () noexcept |
void | cut (Slinknc *link, HTList &list) noexcept |
It makes reference to is_empty(). Referenced by cut_list(). More... | |
void | cut_list (Slinknc *link, HTList &list) noexcept |
void | remove_all_and_delete () noexcept |
size_t | size () const noexcept |
void | rotate_left (size_t n) |
bool | traverse (Operation &operation) noexcept(noexcept(operation)) |
bool | traverse (Operation &operation) const noexcept(noexcept(operation)) |
bool | traverse (Operation &&operation) const noexcept(noexcept(operation)) |
bool | traverse (Operation &&operation) noexcept(noexcept(operation)) |
auto | get_it () const |
auto | get_it (size_t pos) const |
auto | get_itor () const |
T & | nth_ne (const size_t n) noexcept |
const T & | nth_ne (const size_t n) const noexcept |
T & | nth (const size_t n) |
const T & | nth (const size_t n) const |
T * | find_ptr (Operation &operation) noexcept(noexcept(operation)) |
const T * | find_ptr (Operation &operation) const noexcept(noexcept(operation)) |
const T * | find_ptr (Operation &&operation) const noexcept(noexcept(operation)) |
T * | find_ptr (Operation &&operation) noexcept(noexcept(operation)) |
size_t | find_index (Operation &operation) const noexcept(noexcept(operation)) |
size_t | find_index (Operation &&operation) const noexcept(noexcept(operation)) |
std::tuple< bool, T > | find_item (Operation &operation) noexcept(noexcept(operation)) |
std::tuple< bool, T > | find_item (Operation &operation) const noexcept(noexcept(operation)) |
std::tuple< bool, T > | find_item (Operation &&operation) noexcept(noexcept(operation)) |
std::tuple< bool, T > | find_item (Operation &&operation) const noexcept(noexcept(operation)) |
void | emplace (Args &&... args) |
void | emplace_end (Args &&... args) |
void | emplace_ins (Args &&... args) |
size_t | ninsert (Args ... args) |
size_t | nappend (Args ... args) |
void | for_each (Operation &operation) noexcept(noexcept(operation)) |
void | for_each (Operation &operation) const noexcept(noexcept(operation)) |
void | for_each (Operation &&operation) const noexcept(noexcept(operation)) |
void | for_each (Operation &&operation) noexcept(noexcept(operation)) |
void | each (Operation &operation) noexcept(noexcept(operation)) |
void | each (Operation &operation) const noexcept(noexcept(operation)) |
void | each (Operation &&operation) const noexcept(noexcept(operation)) |
void | each (Operation &&operation) noexcept(noexcept(operation)) |
void | each (size_t pos, size_t slice, Operation &operation) const |
void | each (size_t pos, size_t slice, Operation &&operation) const |
void | mutable_for_each (Operation &operation) noexcept(noexcept(operation)) |
void | mutable_for_each (Operation &&operation) noexcept(noexcept(operation)) |
bool | all (Operation &operation) const noexcept(noexcept(operation)) |
bool | all (Operation &&operation) const noexcept(noexcept(operation)) |
bool | exists (Operation &op) const noexcept(noexcept(op)) |
bool | exists (Operation &&op) const noexcept(noexcept(op)) |
DynList< __T > | maps (Operation &op) const |
DynList< __T > | maps (Operation &&op) const |
DynList< __T > | maps_if (Prop prop, Operation &op) const |
DynList< __T > | maps_if (Prop prop, Operation &&op) const |
DynList< T > | to_dynlist () const |
__T | foldl (const __T &init, Op &op) const noexcept(noexcept(op)) |
__T | foldl (const __T &init, Op &&op=Op()) const noexcept(noexcept(op)) |
T | fold (const T &init, Operation &operation) const noexcept(noexcept(operation)) |
T | fold (const T &init, Operation &&operation) const noexcept(noexcept(operation)) |
DynList< T > | filter (Operation &operation) const |
DynList< T > | filter (Operation &&operation) const |
DynList< const T *> | ptr_filter (Operation &operation) const |
DynList< const T *> | ptr_filter (Operation &&operation) const |
DynList< std::tuple< T, size_t > > | pfilter (Operation &operation) const |
DynList< std::tuple< T, size_t > > | pfilter (Operation &&operation) const |
std::pair< DynList< T >, DynList< T > > | partition (Operation &op) const |
std::pair< DynList< T >, DynList< T > > | partition (Operation &&op) const |
std::pair< DynList< T >, DynList< T > > | partition (size_t n) const |
std::tuple< DynList< T >, DynList< T > > | tpartition (Operation &op) const |
std::tuple< DynList< T >, DynList< T > > | tpartition (Operation &&op) const |
size_t | length () const noexcept |
DynList< T > | take (const size_t n) const |
DynList< T > | take (size_t i, size_t j, size_t step=1) const |
DynList< T > | drop (const size_t n) const |
void | mutable_drop (size_t n) |
DynList< T > | items () const |
DynList< T > | keys () const |
iterator | begin () noexcept |
const_iterator | begin () const noexcept |
iterator | end () noexcept |
const_iterator | end () const noexcept |
const_iterator | cbegin () const noexcept |
const_iterator | cbegin () noexcept |
const_iterator | cend () const noexcept |
const_iterator | cend () noexcept |
Sequence of items implemented with a single linked list.
DynList<T>
models list of items of generic type T.
|
inline |
Initialize a list with a copy of all the items of list l
|
inlinenoexcept |
Initialize the list with all the items of l
moved to this
.
This constructor copies (by moving) all the items of list l
. Consequently, no copy is done and the construction takes .
l
is a rvalue reference, take care of that if you are interested in to avoid the copy. So, if you have a lvalue referencde to a list, use std::move()
, upon your responsability, if and only if you are absolutely sure that the list will not be needed after.[in] | l | a rvalue containing a entire list. |
|
inlinenoexceptinherited |
Check if all the elements of container satisfy a condition.
all(operation)
checks if for each element item
of container operation(item)
returns true
.
This method has complexity in average and worst case.
[in] | operation | to be used as condition |
true
if all the elements satisfy the criteria: false
otherwise. anything | that could throw operation |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Insert link as last element
[in] | link | New element that will be inserted |
|
inlinenoexceptinherited |
Join 'this' with 'l' through list end
[in] | l | List that will be inserted through list end |
|
inline |
Append a new item by copy.
Allocate memory for a new item, copy and append it at the end of the list.
<tt>bad_alloc</tt> | if there is no enough memory |
|
inline |
Append a new item by movement.
Allocate memory for a new item, move to its allocated place and append it at the end of the list.
<tt>bad_alloc</tt> | if there is no enough memory |
|
inlinenoexcept |
Append list
at the end of this
by movement.
append(l)
(in this rvalue version), puts in constant time the items of l
at the end of this
. After calling l
becomes empty.
l
is a rvalue reference, take care of that if you are interested in to avoid the copy. So, if you have a lvalue reference to a list, use std::move()
, upon your responsability, if and only if you are absolutely sure that the list will not be needed after.[in] | l | a rvalue reference to the list to be appended |
|
inlinenoexcept |
Append to this
a copy of list
.
This version of append(l)
traverses the items of l
and appends them (copies) into this
.
[in] | l | list to be copied at the end |
bad_alloc | if there is no enough memory |
|
inlinenoexceptinherited |
Concat to 'this' all 'l' list; 'l' becomes empty
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
It makes reference to is_empty().
Referenced by cut_list().
It cuts 'this' over 'link' element and it puts all remaining elements
[in] | link | Element where 'list' will be cut. |
[in] | list | List that will be cut in link |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Drop the first n elements seen in the container during its traversal.
The complexity of this method is where N always is the number of elements of container.
DynList<T>
having the remainder elements according to traversal order. bad_alloc | if there is no enough memory or out_of_range if n is greater or equal than N (the number of elements in the container). |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Traverse all the container and performs a mutable operation on each element.
mutable_for_each(operation)
traverses the container and on each element item
is performed operation(item)
.
operation
could have the following signature:
void operation(T & item)
Be very careful with the fact that this method allows to modify the elements themselves, what could badly alter the internal state of container. This would be the case for heaps, binary trees and hash tables.
[in] | <tt>operation</tt> | to be done on each element. |
this
anything | that can throw operation |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Appends a new element into the container by constructing it in-place with the given args.
emplace(args)
tries to match a constructor T(args)
. If this exists, then this is constructed in-place and directly forwarded to the method append() of container. If all on the container and
T` is adequately done, then the object is constructed once time, successively forwarded and at its target place in the container is moved, avoiding thus unnecessary copies.
append()
is equivalent to insert()
.[in] | args | variadic arguments list |
bad_alloc | if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Insert a new element into the container by constructing it in-place with the given args.
emplace_ins(args)
tries to match a constructor T(args)
. If this exists, then this is constructed in-place and directly forwarded to the method insert() of container. If all on the container and
T` is adequately done, then the object is constructed once time, successively forwarded and finally, at its target place in the container, is moved, avoiding thus unnecessary copies.
insert()
depends of container. In general, this has some sense for lists and arrays and it means insertion at the beginning of sequence. On other type of container append()
is equivalent to insert()
.[in] | args | variadic arguments list |
bad_alloc | if there is no enough memory |
|
inlinenoexceptinherited |
Test for existence in the container of an element satisfying a criteria.
exists(op)
returns true
if it exists any element item
in container for which op(item)
return true
.
This method has complexity in average and worst case.
[in] | op | operation for testing existence |
true
if it exists an item for which op
return true; false
otherwise. anything | that could throw op |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Filter the elements of a container according to a matching criteria.
This method builds a dynamic list with copies of items of container matching a criteria defined by operation
, which should have the following signature:
bool operation(const T & item)
If operation
return true
then item
matches the criteria; otherwise, operation
must return false
.
For example, if the container has integer, the the following code snippet would return a list containing the items greater than 100:
c.filter([] (auto item) { return item > 100; });
[in] | operation | defining the flter criteria |
DynList<T>
with the matched elements. anything | that could throw operation or bad_alloc if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Find the position of an item in the container according to a searching criteria.
find_index(operation)
traverses the container and on each item perform operation(item)
. If the result of operation
is true
, then the traversal is stopped and the position of the current item (which mathes operation
) is returned.
operation
must have the following signature:
bool operation(const typename Container::Item_Type & item)
[in] | <tt>operation</tt> | to be performed on each item for matching a searching criteria. |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Safe sequential searching of an item matching a criteria.
find_item(operation)
traverses the container and on each item perform operation(item)
. If the result of operation
is true
, then the traversal is stopped and duple containg a copy of found item is returned.
The method is said safe because returns a copy of item.
operation
must have the following signature:
bool operation(const typename Container::Item_Type & item)
[in] | <tt>operation</tt> | to be used as searching criteria |
false
and the second is the result of default constructor on the type stored in the container.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Find a pointer to an item in the container according to a searching criteria.
find_ptr(operation)
traverses the container and on each item perform operation(item)
. If the result of operation
is true
, then the traversal is stopped and a pointer to the current item (which mathes operation
) is returned.
operation
must have the following signature:
bool operation(const typename Container::Item_Type & item)
[in] | <tt>operation</tt> | to be performed on each item for matching a searching criteria. |
nullptr
otherwise.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Simplified version of foldl() where the folded type is the same type of elements stored in the container.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Fold the elements of the container to a specific result.
foldl(init, op)
set an internal variable acc
of type __T
to init
value. Then it traverses the container and on each item
it performs:
acc = op(acc, op(acc, item);
So acc
serves as a sort of accumulator.
op
should have the following signature:
__T op(__T acc, const T & item);
Since foldl
is overloaded with several operation structures, there is a certain flexibility with the parameter qualifiers. You could, for example, to declare acc
and/or item
by value.
The method is a template. The first template parameter __T
specifies the final folded type. By default, this type is T
(the type of elements stored in the container). The second parameter is the operation. If the folded type is the same than T
(the type of item stored), the you can simply write a foldl()
. For example, if the container stores integer, in order to determine the maximum of all elements you could do:
c.foldl(std::numeric_limits<int>::min(), [] (int acc, int item) { return std::min(acc, item); });
When the folded type is different than T
, then you must specify the folded type as template parameter. For example, if you want to compute the sum of inversed elements, the you could do it as follows:
c.template foldl<double>(0, [] (double acc, int item) { return acu + 1.0/item; });
[in] | init | initial value of folded value (or accumulator). |
[in] | op | operation to be performed on each item and used for folding. |
anything | that could throw op |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Traverse all the container and performs an operation on each element.
for_each(operation)
traverses the container and on each element item
is performed operation(item)
.
operation
must have the following signature:
void operation(const T & item)
Overloadings of this method allow that that the signature can be lightly different; for example, remove the reference or the const
.
[in] | <tt>operation</tt> | to be done on each element. |
this
anything | that can throw operation |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
Obtains a modifiable reference to the i-th item of this
. Throws overflow_error
if i
is greater or equal to number of elements
|
inline |
Return the first item of the list
underflow_error | if the list is empty |
|
inlinenoexcept |
Return the first item of the list without exception
|
inlinenoexceptinherited |
Return list head (first element)
|
inlineinherited |
Return an properly initialized iterator positioned at the first item on the container
|
inlineinherited |
Return an properly initialized iterator positioned at the pos
item on the container
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
Return the last item of the list
underflow_error | if the list is empty |
|
inlinenoexcept |
Return the last item of the list without exception.
|
inlinenoexceptinherited |
Return list tail (first element)
|
inlinenoexceptinherited |
Insert link as first element
[in] | link | New element that will be inserted |
|
inlinenoexceptinherited |
Insert starting in link (contained in 'this' list) the 'list' list. 'list' becomes empty
[in] | link | Element where 'list' will start |
[in] | list | List that will be inserted after link |
Insert a list
into this
after one of its items.
insert(link, list)
assumes that link
points to a item of this
and inserts in constant time list
just after the item pointed by link
. The order of list
is not altered. but list
becomes empty after insertion.
Suppose the following situation
this-->t1-->t2-->t3-->t4-->t5-->t6-->t7-->t8 ^
| link
l–>l1–>l2–>l3–>l4
Then insert(link, list)
produces:
this-->t1-->t2-->t3-->t4-->l1-->l2-->l3-->l4-->t5-->t6-->t7-->t8
l becomes empty
[in] | link | to the item after one wants to insert list |
[in] | list | to be inserted after item pointed by link |
|
inline |
Insert a new item by copy.
Allocate memory for a new item, copy and insert into the list as the first item.
<tt>bad_alloc</tt> | if there is no enough memory |
|
inline |
Insert a new item by movement.
Allocate memory for a new item, move the item and insert into the list as the first item. This operation can be faster that the equivalent with copy
<tt>bad_alloc</tt> | if there is no enough memory |
|
inlinenoexcept |
Insert list
at the beginning of this
by movement.
insert(l)
(in this rvalue version), puts in constant time the items of l
at the beggining of this
. After calling l
becomes empty.
l
is a rvalue reference, take care of that if you are interested in to avoid the copy. So, if you have a lvalue reference to a list, use std::move()
, upon your responsability, if and only if you are absolutely sure that the list will not be needed after.[in] | l | a rvalue reference to the list to be inserted |
|
inlinenoexcept |
Insert to this
a copy of list
.
This version of insert(l)
traverses the items of l
and insert a copy into this
.
[in] | l | list to be copied at the end |
bad_alloc | if there is no enough memory |
|
inlinenoexceptinherited |
Return true if list is empty
|
inlinenoexceptinherited |
Return true if the list contains exactly just one element
|
inlinenoexceptinherited |
Return true if list contains one element or is empty
|
inlineinherited |
Return a list of all the elements of a container sorted by traversal order.
DynList<T>
containing all the elements of the container bad_alloc | if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Count the number of elements of a container.
This method counts the number of elements stored in the container.
size()
|
inlineinherited |
Map the elements of the container.
maps(op)
produces a dynamic list resulting of mapping of each element of container item
to the result of operation op(item)
.
maps()
is a template method which receives as template parameters the type __T
, which is the type of target or range of mapping, and the transforming operation. By default __T
is the same type of the elements stored in the container.
operation
should have the following signature:
__T operation(const T & item)
So, operation(item)
performs a transformation of item
towards the type __T
.
If __T ==
T`, which is common and by default, then you could specify a mapping without need of template specification. For example, if the container has integer values, the a mapping of item multiplied by 4 could be very simply written as follows:
c.maps([] (int item) { return 4*i; });
In contrast, if the range type is different than the domain type, then it is necessary to specify the template
keyword in the method call. For example, if the range is double
and you want to return the elements divided by 4, the could do as follows:
c.template maps<double>([] (int item) { return 1.0*item/4; });
[in] | op | operation to be performed in order to do the transformation on an item |
anything | that could throw op or bad_alloc if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Conditional mapping of the elements of the container.
maps_if(prop, op)
traverses each item of container, on each item it tests the proposition prop
. If this last is true, then the item is mapped through the function op(item)
.
[in] | op | operation to be perfomed in order to do the transformation on an item . |
[in] | prop | a lambda returning a bool which perform the logical test. |
anything | that could throw op or bad_alloc if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Drop the first n elements seen from container.
The complexity of this method is where N always is the number of elements of container.
out_of_range | if n is greater or equal than N (the number of elements in the container). |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Append n variadic items
[in] | args | items to be appended |
|
inlineinherited |
Insert n variadic items
[in] | args | items to be inserted |
|
inlineinherited |
Return the n-th item of container.
The notion of ordinal depends of type of container. On list, probably will be the insertion order. On binary search trees will be the nth smaller item. On hash tables will be pseudo random.
[in] | n | the nth item to find |
out_of_range | if n is greater or equal that the size of container. |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
Assign to this a copy of l
First, the list is emptied (all its elements are deleted). Then sequential copy of each item of l
is inserted into this
.
This assignation takes in complexity.
[in] | l | list whose items want to be inserted into this |
<tt>bad_alloc</tt> | if there is no enough memory |
|
inlinenoexcept |
Assign to this
by movement the list l
This assignation swaps the content of this
with the content of l
. This swapping is done in .
l
is a rvalue reference, take care of that if you are interested in to avoid the copy. So, if you have a lvalue referencde to a list, use std::move()
, upon your responsability, if and only if you are absolutely sure that the list will not be needed after.[in] | l | a rvalue reference to the list to be assigned by movement. |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Exclusive partition of container according to a filter criteria.
partition(op)
traverses the container and filters its elements according to the filter criteria defined by op
. The filtered elements are copied to a first list and the not filtered ones to a second list. When all the container is traversed, a pair containing these lists is returned.
The op
requirements are the same than for filter()
.
[in] | op | operation instrumenting the filter criteria |
std::pair<DynList<T>, DynList<T>>.
firstcontains the filtered elements and
secondthe non-filtered ones. \throw anything that could throw op or
bad_alloc` if there is no enough memory
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Exclusive partition of container in the nth item
partition(n)
traverses the container and produces a pair of lists. The first one contains the first n
elements and the second one the this->size() - n
remaining elements.
[in] | n | the first n items of the first list |
anything | that could throw op or bad_alloc if there is no enough memory |
|
inlineinherited |
Filter the elements of a container according to a matching criteria and determine its positions respect to the traversal of container.
pfilter(operation)
is very similar to filter()
, but instead of building a list of filtered elements, it builds a list of pairs with form (item, pos)
, where item
is a copy of filtered element and pos
is its position respect to the traversal order. The position is relative to the container type.
The pair is defined with a tuple:
std::tuple<T, size_t>
[in] | operation | that defines the filter criteria |
bad_alloc | if there is no enough memory |
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Filter the elements of a container according to a matching criteria an return pointer to the matched items in the container.
This method builds a dynamic list with stores pointers to the items of matching a criteria defined by operation
, which should have the followgin signature:
bool operation(const T & item)
If operation
return true
then item
matches the criteria; otherwise, operation
must return false
.
For example, if the container has integer, the the following code snippet would return a list containing the items greater than 100:
c.ptr_filter([] (auto item) { return item > 100; });
[in] | operation | defining the flter criteria |
DynList<const T*>
with the pointers to the matched elements. anything | that could throw operation or bad_alloc if there is no enough memory |
|
inlinenoexceptinherited |
Insert link as first element
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Insert link as last element
|
inlinenoexcept |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexcept |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Remove from the list the item pointed by link
remove(link)
perform a sequential traversal of this
until find link
. Then link
is removed.
This method has a complexity of for worst and average case.
[in] | link | pointer to the item to be removed. |
true
if link
was found and removed: false
otherwise underflow_error | if the list is empty |
|
inline |
Remove the first item of the list.
underflow_error | if the list is empty |
|
inline |
Remove the first element matching an equality criteria.
remove(eq)
sequentially traverses the list and on each current element curr
it calls to eq(curr)
. If the test is true
, then curr
is removed from the list and a copy of ciirr
is returned. Otherwise, if no element matches with eq()
test, then exception domain_error
is thrown.
The eq()
must match the following signature:
bool eq(const T& op)
This test would return true
when op
satisfies the finding criteria`.
Since that this method is overloaded, you could define several flavors: a more sophisticated functor, function pointers or lambdas.
[in] | eq | equality test |
domain_error
is thrown.
|
inlinenoexceptinherited |
Remove and free memory for all the items of list.
remove_all_and_delete()
remove each item of the list and call to delete
operator on the removed item. At the end of call, all the items were removed, all the memory freed qand the list emptied.
new
. Although That is very frequently the case, there are some exceptions. So, be sure that the items were allocated with new
operator.
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexcept |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Remove the header item from the list.
underflow_error | if the list is empty |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Remove the first item of this
.
This synonym is adequate when this
is dealed as a stack.
underflow_error | if the list is empty |
|
inlinenoexceptinherited |
It deletes head element (first one). Return deleted element
|
inlinenoexcept |
Remove the first item of the list without exception.
underflow_error | if the list is empty |
|
inline |
Return a reversed copy of this
. Not confuse with reverse without const
which mutates this
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Rotate to left the list n positions.
rotate_left(n)
rotates the items to left n
positions. For example, if the list is as follows:
l0, l1, l2, l3, l4, l5, l6, l7, l8, l9
Then rotate_left(4)
produces the following state:
l4, l5, l6, l7, l8, l9, l0, l1, l2, l3
[in] | n | the number of position to be rotated |
domain_error | if list is empty |
|
inlinenoexceptinherited |
Count the number of elements of the list.
This method counts, it does not retrieve, the number of elements stored in the list.
So it is complexity is . This is some polemic because one could maintain an internal counter and retrieve it in constant time. It possible that this feauture is put in next versions. We do not maintain this counter because it is possible to add or remove items from a given node. So these operations would require access to the full list's context, what it often not the case.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
It divides 'this' into two equal lists without modifying elements order
Split the list in two.
This method takes the first n/2 items of `this` and puts them, in the same order, in list `l`. The remainder items are put in list `r`. After operation `this` becomes empty. The order of items is preserved through `l` and `r`. \param[out] l list containg the first n/2 first items \param[out] r list containg the last n/2 first items \return the total of items that has `this`
Swap in constant time (very fast) 'this' elements with 'l' list elements
Referenced by append(), insert(), reverse() and split_list().
Exchange 'this' values with another list
[in] | l | New list which elements will be exchanged |
|
inlinenoexcept |
Swap this with l. All items of each list are swapped in constant time
|
inlineinherited |
Return a list with the first n elements seen in the container during its traversal.
The complexity of this method is where n can be less than the number of elements of container.
DynList<T>
having the first n
elements according to its traversal order. bad_alloc | if there is no enough memory or out_of_range if n is greater or equal than the number of elements in the container. |
|
inlineinherited |
Return a list with elements seen in the container between i and j position respect to its traversal.
The complexity of this method is where n can be less than the number of elements of container.
DynList<T>
having the first n
elements according to its traversal order. bad_alloc | if there is no enough memory or out_of_range if n is greater or equal than the number of elements in the container. |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlineinherited |
Exclusive partition of container according to a filter criteria.
This methos has exactly the same semantic than partition(Operation & op)
, excepts than instead of returning a std::pair
it returns a std::tuple
.
[in] | op | operation instrumenting the filter criteria |
std::tuple<DynList<T>, DynList<T>>.
firstcontains the filteres elements and
secondthe non-filtered ones. \throw anything that could throw op or
bad_alloc` if there is no enough memory
|
inlineinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
Traverse the container via its iterator and performs a conditioned operation on each item.
traverse(operation)
instantiates the internal iterator of the class and traverses each item performing operation(item)
.
operation
must have the following signature:
bool operation(const typename Container::Item_Type & item)
If operation(item)
returns true
then the iterator is advanced and the next item processed. Otherwise. the traversal stops.
[in] | operation | to be performed on each item |
true
if all the items were visited (operation
on each one always returned true
) or false
if the traversal was stoppep because there was a false
result on an item. anything | that could throw operation |
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
inlinenoexceptinherited |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.