diff --git a/alib2std/src/extensions/forward_list.hpp b/alib2std/src/extensions/forward_list.hpp
index b265d1729a703aedca138414c860f15e4fe57e83..5cd124010bee89f1e221f60b0ea11ad97cb162dc 100644
--- a/alib2std/src/extensions/forward_list.hpp
+++ b/alib2std/src/extensions/forward_list.hpp
@@ -82,6 +82,66 @@ public:
*/
forward_list & operator = ( const forward_list & other ) = default;
#endif
+
+ /**
+ * \brief
+ * Inherited behavior of begin for non-const instance.
+ *
+ * \return iterator the first element of forward_list
+ */
+ auto begin ( ) & {
+ return std::forward_list < T, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for const instance.
+ *
+ * \return const_iterator the first element of forward_list
+ */
+ auto begin ( ) const & {
+ return std::forward_list < T, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for rvalues.
+ *
+ * \return move_iterator the first element of forward_list
+ */
+ auto begin ( ) && {
+ return make_move_iterator ( this->begin ( ) );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for non-const instance.
+ *
+ * \return iterator to one after the last element of forward_list
+ */
+ auto end ( ) & {
+ return std::forward_list < T, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for const instance.
+ *
+ * \return const_iterator to one after the last element of forward_list
+ */
+ auto end ( ) const & {
+ return std::forward_list < T, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for rvalues.
+ *
+ * \return move_iterator to one after the last element of forward_list
+ */
+ auto end ( ) && {
+ return make_move_iterator ( this->end ( ) );
+ }
};
/**
diff --git a/alib2std/src/extensions/unordered_map.hpp b/alib2std/src/extensions/unordered_map.hpp
index 3a433e672bdb0c5e6e1517d9dc7a5d5838dde44e..82785aca767a115ea666d465a19a198bee518165 100644
--- a/alib2std/src/extensions/unordered_map.hpp
+++ b/alib2std/src/extensions/unordered_map.hpp
@@ -1,6 +1,22 @@
/*
* unordered_map.hpp
*
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit. If not, see <http://www.gnu.org/licenses/>.
+ *
* Created on: Feb 28, 2014
* Author: Jan Travnicek
*/
@@ -15,33 +31,232 @@
#include "compare.hpp"
#include "allocFix.hpp"
+#include "iterator.hpp"
namespace ext {
+/**
+ * \brief
+ * Class extending the unordered_map class from the standard library. Original reason is to allow printing of the container with overloaded operator <<.
+ *
+ * The class mimics the behavior of the unordered_map from the standatd library.
+ *
+ * \tparam T the type of keys inside the unordered_map
+ * \tparam R the type of values inside the unordered_map
+ * \tparam Hash the hasher type used to order keys
+ * \tparam KeyEqual the comparator of keys
+ * \tparam Alloc the allocator of values of type T
+ */
template < class T, class R, class Hash = std::hash < T >, class KeyEqual = std::equal_to < T >, class Alloc = std::allocator < std::pair < const T, R > > >
class unordered_map : public std::unordered_map < T, R, Hash, KeyEqual, Alloc >, AllocFix < Alloc > {
public:
+ /**
+ * Inherit constructors of the standard unordered_map
+ */
using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::unordered_map;
+
+ /**
+ * Inherit operator = of the standard unordered_map
+ */
using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::operator =;
#ifndef __clang__
+
+ /**
+ * Default constructor needed by g++ since it is not inherited
+ */
unordered_map ( ) = default;
+ /**
+ * Copy constructor needed by g++ since it is not inherited
+ */
unordered_map ( const unordered_map & other ) = default;
+ /**
+ * Move constructor needed by g++ since it is not inherited
+ */
unordered_map ( unordered_map && other ) = default;
+ /**
+ * Copy operator = needed by g++ since it is not inherited
+ */
unordered_map & operator = ( unordered_map && other ) = default;
+ /**
+ * Move operator = needed by g++ since it is not inherited
+ */
unordered_map & operator = ( const unordered_map & other ) = default;
#endif
+
+ /**
+ * \brief
+ * The iterator type is inheried.
+ */
+ using iterator = typename std::unordered_map<T, R, Hash, KeyEqual, Alloc>::iterator;
+
+ /**
+ * \brief
+ * Temporary implementation of insert_or_assign from c++17 standard.
+ * TODO: Remove this member function after move to C++17
+ *
+ * Follows interface from C++17 version of insert_or_assign
+ *
+ * \tparam M type of the value to insert
+ *
+ * \param k the key
+ * \param obj the value
+ *
+ * \return pair of iterator to the inserted or assigned key-value pair and true if the value was inserted or false if the value was asigned
+ */
+ template < typename M >
+ std::pair < iterator, bool > insert_or_assign ( const T & k, M && obj ) {
+ iterator pos = this->find ( k );
+ if ( pos == this->end ( ) ) {
+ pos = this->insert ( k, std::forward < M > ( obj ) ).first;
+ return std::make_pair ( pos, true );
+ } else {
+ pos->second = std::forward < M > ( obj );
+ return std::make_pair ( pos, false );
+ }
+ }
+
+ /**
+ * \brief
+ * Inherit all insert methods of the standard unordered_map.
+ */
+ using std::unordered_map< T, R, Hash, KeyEqual, Alloc >::insert;
+
+ /**
+ * \brief
+ * Insert variant with explicit key and value parameters.
+ *
+ * \param key the key
+ * \param value the value
+ *
+ * \return pair of iterator to inserted key-value pair and true if the value was inserted or false if the key already exited
+ */
+ std::pair < iterator, bool > insert ( const T & key, const R & value ) {
+ return insert ( std::make_pair ( key, value ) );
+ }
+
+ /**
+ * \brief
+ * Insert variant with explicit key and value parameters.
+ *
+ * \param key the key
+ * \param value the value
+ *
+ * \return pair of iterator to inserted key-value pair and true if the value was inserted or false if the key already exited
+ */
+ std::pair < iterator, bool > insert ( const T & key, R && value ) {
+ return insert ( std::make_pair ( key, std::move ( value ) ) );
+ }
+
+ /**
+ * \brief
+ * Insert variant with explicit key and value parameters.
+ *
+ * \param key the key
+ * \param value the value
+ *
+ * \return pair of iterator to inserted key-value pair and true if the value was inserted or false if the key already exited
+ */
+ std::pair < iterator, bool > insert ( T && key, const R & value ) {
+ return insert ( std::make_pair ( std::move ( key ), value ) );
+ }
+
+ /**
+ * \brief
+ * Insert variant with explicit key and value parameters.
+ *
+ * \param key the key
+ * \param value the value
+ *
+ * \return pair of iterator to inserted key-value pair and true if the value was inserted or false if the key already exited
+ */
+ std::pair < iterator, bool > insert ( T && key, R && value ) {
+ return insert ( std::make_pair ( std::move ( key ), std::move ( value ) ) );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for non-const instance.
+ *
+ * \return iterator the first element of unordered_map
+ */
+ auto begin ( ) & {
+ return std::unordered_map < T, R, Hash, KeyEqual, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for const instance.
+ *
+ * \return const_iterator the first element of unordered_map
+ */
+ auto begin ( ) const & {
+ return std::unordered_map < T, R, Hash, KeyEqual, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * New variant of begin for rvalues.
+ *
+ * \return move_iterator the first element of unordered_map
+ */
+ auto begin ( ) && {
+ return make_map_move_iterator < T, R > ( this->begin ( ) );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for non-const instance.
+ *
+ * \return iterator to one after the last element of unordered_map
+ */
+ auto end ( ) & {
+ return std::unordered_map < T, R, Hash, KeyEqual, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for const instance.
+ *
+ * \return const_iterator to one after the last element of unordered_map
+ */
+ auto end ( ) const & {
+ return std::unordered_map < T, R, Hash, KeyEqual, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * New variant of end for rvalues.
+ *
+ * \return move_iterator to one after the last element of unordered_map
+ */
+ auto end ( ) && {
+ return make_map_move_iterator < T, R > ( this->end ( ) );
+ }
};
+/**
+ * \brief
+ * Operator to print the unordered_map to the output stream.
+ *
+ * \param out the output stream
+ * \param unordered_map the unordered_map to print
+ *
+ * \tparam T the type of keys inside the unordered_map
+ * \tparam R the type of values inside the unordered_map
+ * \tparam Ts ... remaining unimportant template parameters of the unordered_map
+ *
+ * \return the output stream from the \p out
+ */
template< class T, class R, class ... Ts >
-std::ostream& operator<<(std::ostream& out, const ext::unordered_map<T, R, Ts ... >& map) {
+std::ostream& operator<<(std::ostream& out, const ext::unordered_map<T, R, Ts ... >& unordered_map) {
out << "{";
bool first = true;
- for(const std::pair<const T, R>& item : map) {
+ for(const std::pair<const T, R>& item : unordered_map) {
if(!first) out << ", ";
first = false;
out << "(" << item.first << ", " << item.second << ")";
@@ -51,8 +266,26 @@ std::ostream& operator<<(std::ostream& out, const ext::unordered_map<T, R, Ts ..
return out;
}
+/**
+ * \brief
+ * Specialisation of the compare structure implementing the three-way comparison.
+ *
+ * \tparam T the type of keys inside the unordered_map
+ * \tparam R the type of values inside the unordered_map
+ * \tparam Ts ... remaining unimportant template parameters of the unordered_map
+ */
template<class T, class R, class ... Ts>
struct compare<ext::unordered_map<T, R, Ts ...>> {
+
+ /**
+ * \brief
+ * Implementation of the three-way comparison.
+ *
+ * \param first the left operand of the comparison
+ * \param second the right operand of the comparison
+ *
+ * \return negative value of left < right, positive value if left > right, zero if left == right
+ */
int operator()(const ext::unordered_map<T, R, Ts ...>& first, const ext::unordered_map<T, R, Ts ...>& second) const {
if(first.size() < second.size()) return -1;
if(first.size() > second.size()) return 1;
@@ -68,6 +301,17 @@ struct compare<ext::unordered_map<T, R, Ts ...>> {
}
};
+/**
+ * \brief
+ * Overload of to_string function.
+ *
+ * \param value the unordered_map to be converted to string
+ *
+ * \tparam T the type of values inside the unordered_map
+ * \tparam Ts ... remaining unimportant template parameters of the unordered_map
+ *
+ * \return string representation
+ */
template < class T, class R >
std::string to_string ( const ext::unordered_map < T, R > & value ) {
std::stringstream ss;
diff --git a/alib2std/src/extensions/utility.hpp b/alib2std/src/extensions/utility.hpp
index 3b90db10b0abd1c95787b7d9396d592efeeb6a51..972605ac032e4ac28919825b7ee4dbb5abd162c9 100644
--- a/alib2std/src/extensions/utility.hpp
+++ b/alib2std/src/extensions/utility.hpp
@@ -1,6 +1,22 @@
/*
* utility.hpp
*
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit. If not, see <http://www.gnu.org/licenses/>.
+ *
* Created on: Apr 7, 2016
* Author: Jan Travnicek
*/
@@ -15,52 +31,136 @@
namespace ext {
+/**
+ * \brief
+ * Extension of sizeof mimicking behavior of regular sizeof operator.
+ *
+ * Provides field size as result of sizeof operator
+ *
+ * \tparam T the tested type
+ */
template<class T>
struct SizeOf {
+ /**
+ * \brief
+ * The value of sizeof operator on the type T.
+ */
static const size_t size = sizeof(T);
};
+/**
+ * \brief
+ * Specialised sizeof extension for void type. The void type is resulting into the size 1.
+ *
+ * Provides field size as result of sizeof operator
+ */
template<>
struct SizeOf<void> {
+ /**
+ * \brief
+ * The size for void type is set to 1.
+ */
static const size_t size = 1;
};
+/**
+ * \brief
+ * Extension of alignof mimicking behavior of regular alignof operator.
+ *
+ * Provides field align as result of sizeof operator
+ *
+ * \tparam T the tested type
+ */
template<class T>
struct AlignOf {
+ /**
+ * \brief
+ * The value of alignof operator on the type T.
+ */
static const size_t align = alignof(T);
};
+/**
+ * \brief
+ * Specialised alignof extension for void type. The void type is resulting into the align 1.
+ *
+ * Provides field align as result of alignof operator
+ */
template<>
struct AlignOf<void> {
+ /**
+ * \brief
+ * The align for void type is set to 1.
+ */
static const size_t align = 1;
};
-template < class T, typename std::enable_if < ! ext::has_clone < T >::value >::type * = nullptr >
-inline T move_copy ( const T & param ) {
- return T ( param );
-}
-
+/**
+ * \brief
+ * Class representing wrapper of dynamically allocated object behaving like rvalue reference.
+ *
+ * The class takes ownership of the dynamically allocated object
+ *
+ * \tparam the type of value wrapped
+ */
template < class T >
-struct rvalue_ref {
+class rvalue_ref {
+ /**
+ * \brief
+ * Owned dynamically allocated object
+ */
T * holder;
+public:
+ /**
+ * \brief
+ * Constructor of the rvalue_ref from dynaically allocated object. The class will take ownerhip of the pointer.
+ */
explicit rvalue_ref ( T * ptr ) : holder ( ptr ) {
}
+ /**
+ * \brief
+ * User conversion constructor from rvalue_ref for type U where T is its predecessor
+ *
+ * \tparam U the subtype of T
+ *
+ * \param other the other instance
+ */
template < class U >
rvalue_ref ( rvalue_ref < U > && other ) : holder ( other.holder ) {
other.holder = nullptr;
}
+ /**
+ * \brief
+ * Copy construction is not allowed.
+ */
rvalue_ref ( const rvalue_ref & ) = delete;
+ /**
+ * \brief
+ * Move construction will transfer ownership of the pointer from source instance to newly created one.
+ *
+ * \param other the other instance
+ */
rvalue_ref ( rvalue_ref && other) : holder( other.holder ) {
other.holder = nullptr;
};
+ /**
+ * \brief
+ * Copy assignment is not allowed.
+ */
rvalue_ref & operator = ( const rvalue_ref & ) = delete;
+ /**
+ * \param
+ * Move assignment will swap holded pointers between the two instances.
+ *
+ * \param other the other instance.
+ */
rvalue_ref & operator = ( rvalue_ref && other ) {
using std::swap;
@@ -69,27 +169,93 @@ struct rvalue_ref {
return *this;
}
+ /**
+ * \brief
+ * Destructor will free the owned instance.
+ */
~rvalue_ref ( ) {
delete holder;
}
+ /**
+ * \brief
+ * Arrow operator to chain dereference.
+ *
+ * \return the owned pointer
+ */
T * operator ->( ) && {
return holder;
}
- T * operator ->( ) const & {
+ /**
+ * \brief
+ * Arrow operator to chain dereference.
+ *
+ * \return the owned pointer
+ */
+ T * operator ->( ) & {
+ return holder;
+ }
+
+ /**
+ * \brief
+ * Arrow operator to chain dereference.
+ *
+ * \return the owned pointer
+ */
+ const T * operator ->( ) const & {
return holder;
}
+ /**
+ * \brief
+ * Allow automatic cast to rvalue reference.
+ *
+ * \return the holded value
+ */
operator T && ( ) {
return std::move ( * holder );
}
+ /**
+ * \brief
+ * Getter of the holded value.
+ *
+ * \return constant reference to the holded value
+ */
const T & get ( ) const {
return * holder;
}
+
+ template < class U >
+ friend class rvalue_ref;
};
+/**
+ * \brief
+ * Allow moving of copied instance of the source. Designed for copyconstructible objects.
+ *
+ * \tparam T the type of processed instance
+ *
+ * \param param the source instance
+ *
+ * \return copy to be moved from
+ */
+template < class T, typename std::enable_if < ! ext::has_clone < T >::value >::type * = nullptr >
+inline T move_copy ( const T & param ) {
+ return T ( param );
+}
+
+/**
+ * \brief
+ * Allow moving of copied instance of the source. Designed for cloneable objects.
+ *
+ * \tparam T the type of processed instance
+ *
+ * \param param the source instance
+ *
+ * \return wrapper of dynamically allocated copy supporting cast to rvalue reference to T
+ */
template < class T, typename std::enable_if < ext::has_clone < T >::value >::type * = nullptr >
inline rvalue_ref < T > move_copy ( const T & param ) {
return rvalue_ref < T > { param.clone ( ) };
diff --git a/alib2std/src/extensions/variant.hpp b/alib2std/src/extensions/variant.hpp
index 9bf2bc7863e6472c35be4ca9d5644619fe93a73a..3537bb6ce564184479023b1449df9a182d67eccc 100644
--- a/alib2std/src/extensions/variant.hpp
+++ b/alib2std/src/extensions/variant.hpp
@@ -1,6 +1,22 @@
/**
* variant.hpp
*
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit. If not, see <http://www.gnu.org/licenses/>.
+ *
* https://gist.github.com/tibordp/6909880
*
* Created on: Feb 28, 2014
diff --git a/alib2std/src/extensions/vector.hpp b/alib2std/src/extensions/vector.hpp
index 1920b29b386f24ed65625a78b55418750b52c222..37542685542b4e9a1c27c53e51f58a2520837aad 100644
--- a/alib2std/src/extensions/vector.hpp
+++ b/alib2std/src/extensions/vector.hpp
@@ -1,6 +1,22 @@
/*
* vector.hpp
*
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit. If not, see <http://www.gnu.org/licenses/>.
+ *
* Created on: Feb 28, 2014
* Author: Jan Travnicek
*/
@@ -20,24 +36,128 @@
namespace ext {
+/**
+ * \brief
+ * Class extending the vector class from the standard library. Original reason is to allow printing of the container with overloaded operator <<.
+ *
+ * The class mimics the behavior of the vector from the standatd library.
+ *
+ * \tparam T the type of values inside the vector
+ * \tparam Alloc the allocator of values of type T
+ */
template < class T, class Alloc = std::allocator < T > >
class vector : public std::vector < T, Alloc >, AllocFix < Alloc > {
public:
+ /**
+ * Inherit constructors of the standard vector
+ */
using std::vector< T, Alloc >::vector;
+
+ /**
+ * Inherit operator = of the standard vector
+ */
using std::vector< T, Alloc >::operator =;
#ifndef __clang__
+
+ /**
+ * Default constructor needed by g++ since it is not inherited
+ */
vector ( ) = default;
+ /**
+ * Copy constructor needed by g++ since it is not inherited
+ */
vector ( const vector & other ) = default;
+ /**
+ * Move constructor needed by g++ since it is not inherited
+ */
vector ( vector && other ) = default;
+ /**
+ * Copy operator = needed by g++ since it is not inherited
+ */
vector & operator = ( vector && other ) = default;
+ /**
+ * Move operator = needed by g++ since it is not inherited
+ */
vector & operator = ( const vector & other ) = default;
#endif
+
+ /**
+ * \brief
+ * Inherited behavior of begin for non-const instance.
+ *
+ * \return iterator the first element of vector
+ */
+ auto begin ( ) & {
+ return std::vector < T, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for const instance.
+ *
+ * \return const_iterator the first element of vector
+ */
+ auto begin ( ) const & {
+ return std::vector < T, Alloc >::begin ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of begin for rvalues.
+ *
+ * \return move_iterator the first element of vector
+ */
+ auto begin ( ) && {
+ return make_move_iterator ( this->begin ( ) );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for non-const instance.
+ *
+ * \return iterator to one after the last element of vector
+ */
+ auto end ( ) & {
+ return std::vector < T, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for const instance.
+ *
+ * \return const_iterator to one after the last element of vector
+ */
+ auto end ( ) const & {
+ return std::vector < T, Alloc >::end ( );
+ }
+
+ /**
+ * \brief
+ * Inherited behavior of end for rvalues.
+ *
+ * \return move_iterator to one after the last element of vector
+ */
+ auto end ( ) && {
+ return make_move_iterator ( this->end ( ) );
+ }
};
+/**
+ * \brief
+ * Operator to print the vector to the output stream.
+ *
+ * \param out the output stream
+ * \param vector the vector to print
+ *
+ * \tparam T the type of values inside the vector
+ * \tparam Ts ... remaining unimportant template parameters of the vector
+ *
+ * \return the output stream from the \p out
+ */
template< class T , class ... Ts >
std::ostream& operator<<(std::ostream& out, const ext::vector<T, Ts ...>& vector) {
out << "[";
@@ -53,8 +173,25 @@ std::ostream& operator<<(std::ostream& out, const ext::vector<T, Ts ...>& vector
return out;
}
+/**
+ * \brief
+ * Specialisation of the compare structure implementing the three-way comparison.
+ *
+ * \tparam T the type of values inside the vector
+ * \tparam Ts ... remaining unimportant template parameters of the vector
+ */
template<class T, class ... Ts>
struct compare<ext::vector<T, Ts ...>> {
+
+ /**
+ * \brief
+ * Implementation of the three-way comparison.
+ *
+ * \param first the left operand of the comparison
+ * \param second the right operand of the comparison
+ *
+ * \return negative value of left < right, positive value if left > right, zero if left == right
+ */
int operator()(const ext::vector<T, Ts...>& first, const ext::vector<T, Ts...>& second) const {
if(first.size() < second.size()) return -1;
if(first.size() > second.size()) return 1;
@@ -68,6 +205,17 @@ struct compare<ext::vector<T, Ts ...>> {
}
};
+/**
+ * \brief
+ * Overload of to_string function.
+ *
+ * \param value the vector to be converted to string
+ *
+ * \tparam T the type of values inside the vector
+ * \tparam Ts ... remaining unimportant template parameters of the vector
+ *
+ * \return string representation
+ */
template < class T, class ... Ts >
std::string to_string ( const ext::vector < T, Ts ... > & value ) {
std::stringstream ss;
@@ -88,6 +236,17 @@ inline vectorBoolInternalType getMask ( size_t dist ) {
return ( ( vectorBoolInternalType { } + 1 ) << dist ) - 1;
}*/
+/**
+ * \brief
+ * Support for assigning or operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the destination instance
+ * \param B the source instance
+ *
+ * \return modified A instance with each bit is result of or operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > & operator |= ( ext::vector < bool, Ts ... > & A, const ext::vector < bool, Ts ... > & B ) {
// c++ implementation-specific
@@ -118,12 +277,34 @@ ext::vector < bool, Ts ... > & operator |= ( ext::vector < bool, Ts ... > & A, c
return A;
}
+/**
+ * \brief
+ * Support for or operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the first source instance
+ * \param B the second source instance
+ *
+ * \return new vector of booleans with each bit is result of or operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator | ( ext::vector < bool, Ts ... > A, const ext::vector < bool, Ts ... > & B ) {
A |= B;
return A;
}
+/**
+ * \brief
+ * Support for assigning and operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the destination instance
+ * \param B the source instance
+ *
+ * \return modified A instance with each bit is result of and operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > & operator &= ( ext::vector < bool, Ts ... > & A, const ext::vector < bool, Ts ... > & B ) {
// c++ implementation-specific
@@ -159,12 +340,34 @@ ext::vector < bool, Ts ... > & operator &= ( ext::vector < bool, Ts ... > & A, c
return A;
}
+/**
+ * \brief
+ * Support for and operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the first source instance
+ * \param B the second source instance
+ *
+ * \return new vector of booleans with each bit is result of and operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator & ( ext::vector < bool, Ts ... > A, const ext::vector < bool, Ts ... > & B ) {
A &= B;
return A;
}
+/**
+ * \brief
+ * Support for assigning xor operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the destination instance
+ * \param B the source instance
+ *
+ * \return modified A instance with each bit is result of xor operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > & operator ^= ( ext::vector < bool, Ts ... > & A, const ext::vector < bool, Ts ... > & B ) {
// c++ implementation-specific
@@ -199,18 +402,50 @@ ext::vector < bool, Ts ... > & operator ^= ( ext::vector < bool, Ts ... > & A, c
return A;
}
+/**
+ * \brief
+ * Support for xor operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the first source instance
+ * \param B the second source instance
+ *
+ * \return new vector of booleans with each bit is result of xor operation between respective bits in A and B instances
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator ^ ( ext::vector < bool, Ts ... > A, const ext::vector < bool, Ts ... > & B ) {
A ^= B;
return A;
}
+/**
+ * \brief
+ * Support for not operator.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the source instance
+ *
+ * \return new vector of booleans with each bit from the source instance inverted
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator ~ ( ext::vector < bool, Ts ... > A ) {
A.flip ( );
return A;
}
+/**
+ * \brief
+ * Support for assigning bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the source instance
+ * \param dist the distance to shift by
+ *
+ * \return modified A instance with each bit moved by dist positions to higher indexes
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > & operator <<= ( ext::vector < bool, Ts ... > & A, size_t dist ) {
/* if ( A.size ( ) == 0 )
@@ -269,12 +504,34 @@ ext::vector < bool, Ts ... > & operator <<= ( ext::vector < bool, Ts ... > & A,
return A;
}
+/**
+ * \brief
+ * Support for bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the source instance
+ * \param dist the distance to shift by
+ *
+ * \return new instnace of vector of booleans with each bit moved by dist positions to higher indexes
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator << ( ext::vector < bool, Ts ... > A, size_t dist ) {
A <<= dist;
return A;
}
+/**
+ * \brief
+ * Support for assigning bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the source instance
+ * \param dist the distance to shift by
+ *
+ * \return modified A instance with each bit moved by dist positions to lower indexes
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > & operator >>= ( ext::vector < bool, Ts ... > & A, size_t dist ) {
/*if ( A.size ( ) == 0 )
@@ -337,12 +594,35 @@ ext::vector < bool, Ts ... > & operator >>= ( ext::vector < bool, Ts ... > & A,
return A;
}
+/**
+ * \brief
+ * Support for bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param A the source instance
+ * \param dist the distance to shift by
+ *
+ * \return new instnace of vector of booleans with each bit moved by dist positions to lower indexes
+ */
template < class ... Ts >
ext::vector < bool, Ts ... > operator >> ( ext::vector < bool, Ts ... > A, size_t dist ) {
A >>= dist;
return A;
}
+/**
+ * \brief
+ * Tests the vector of booleans whether at least one bit inside is set.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param v the tested instance
+ *
+ * \return true if at least one bit in the vector is set, false othervise
+ *
+ * //TODO make a method of vector of booleans
+ */
template < class ... Ts >
bool any ( const ext::vector < bool, Ts ... > & v ) {
// c++ implementation-specific
@@ -365,6 +645,16 @@ bool any ( const ext::vector < bool, Ts ... > & v ) {
return false;
}
+/**
+ * \brief
+ * Sets all bits in the vector of booleans.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param v the modified instance
+ *
+ * //TODO make a method of vector of booleans
+ */
template < class ... Ts >
void fill ( ext::vector < bool, Ts ... > & v ) {
// c++ implementation-specific
@@ -379,6 +669,16 @@ void fill ( ext::vector < bool, Ts ... > & v ) {
* itV = true;
}
+/**
+ * \brief
+ * Clears all bits in the vector of booleans.
+ *
+ * \tparam Ts ... additional parameters of vector of booleans
+ *
+ * \param v the modified instance
+ *
+ * //TODO make a method of vector of booleans
+ */
template < class ... Ts >
void clear ( ext::vector < bool, Ts ... > & v ) {
// c++ implementation-specific