algorithm.h File Reference

#include <algorithm>
#include <map>
#include <numeric>
#include <unordered_map>
#include <vector>
#include "TemplateMetaProgramming.h"

Include dependency graph for algorithm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	armarx
	This file offers overloads of toIce() and fromIce() functions for STL container types.
namespace	std

Enumerations
enum class	MergeMapsMode { OverrideOldValues , KeepOldValues , OverrideNoValues }

Functions
template<class ContainerType, class ElementType>
bool	Contains (const ContainerType &container, const ElementType &searchElement)
template<class ContainerT, class IndexContainerT, class IndexT = typename IndexContainerT::value_type>
std::vector< typename ContainerT::value_type >	copyValuesAt (const ContainerT &src, const IndexContainerT &idx)
	Uses the container of indices to copy values (accessed via src.at()) from the given container into a vector and returns his vector.
template<class ContainerT, class IndexContainerT, class OutputIteratorT, class IndexT = typename IndexContainerT::value_type>
void	copyValuesAt (const ContainerT &src, const IndexContainerT &idx, OutputIteratorT dest)
	Uses the container of indices to copy values (accessed via src.at())from the given container into the output iterator.
template<class ContainerT, class IndexIteratorT, class IndexT = typename std::iterator_traits<IndexIteratorT>::value_type>
std::vector< typename ContainerT::value_type >	copyValuesAt (const ContainerT &src, IndexIteratorT fst, IndexIteratorT lst)
	Uses the range of indices to copy values (accessed via src.at())from the given container into a vector and returns his vector.
template<class ContainerT, class IndexIteratorT, class OutputIteratorT, class IndexT = typename std::iterator_traits<IndexIteratorT>::value_type>
void	copyValuesAt (const ContainerT &src, IndexIteratorT fst, IndexIteratorT lst, OutputIteratorT dest)
	Uses the range of indices to copy values (accessed via src.at())from the given container into the output iterator.
template<class KeyT, class ValT>
std::vector< KeyT >	getIndices (const std::map< KeyT, ValT > &c)
template<class KeyT, class ValT>
std::vector< KeyT >	getIndices (const std::unordered_map< KeyT, ValT > &c)
template<class ValT>
std::vector< std::size_t >	getIndices (const std::vector< ValT > &c)
template<class MapType>
std::vector< typename MapType::key_type >	getMapKeys (const MapType &map)
template<class MapType, class OutputIteratorType>
void	getMapKeys (const MapType &map, OutputIteratorType it)
template<class MapType, template< class... > class ContainerT = std::vector>
ContainerT< typename MapType::mapped_type >	getMapValues (const MapType &map)
template<class MapType, class OutputIteratorType>
void	getMapValues (const MapType &map, OutputIteratorType it)
void	incrementAll ()
	Increment all given parameter using the pre-increment operator.
template<typename It0, typename... It>
void	incrementAll (It0 &it0, It &... it)
template<class T, class... Ts>
bool	isfinite (const std::vector< T, Ts... > &v)
template<typename T>
void	mergeMaps (T &oldMap, const T &newMap, MergeMapsMode mergeMode=MergeMapsMode::OverrideOldValues)
	Inserts and overwrites the values from oldMap with the values from newMap.
template<class T>
T	sign (T t)
template<class T, class MapType = std::unordered_map<typename T::value_type, typename T::size_type>>
MapType	toIndexMap (const T &vec)
	This function takes a container (e.g.
template<class OutputT, class InputT, typename Alloc, template< class, class > class Container>
auto	transform (const Container< InputT, Alloc > &in, OutputT(*func)(InputT const &)) -> Container< OutputT, typename std::allocator_traits< Alloc >::template rebind_alloc< OutputT > >
	Convenience function (with less typing) to transform a container of type InputT into the same container type of type OutputT.
template<class MapInT, class TransformT, class MapOutT = MapInT>
void	transformMapKeys (const MapInT &inMap, MapOutT &outMap, TransformT transform)
template<class MapInT, class TransformT, class MapOutT = MapInT>
MapOutT	transformMapKeys (const MapInT &inMap, TransformT transform)