Trinity::Containers Namespace Reference

Functions
template<class T >
void	RandomResizeList (std::list< T > &list, uint32 size)
template<class T , class Predicate >
void	RandomResizeList (std::list< T > &list, Predicate &predicate, uint32 size)
template<class C >
C::value_type const &	SelectRandomContainerElement (C const &container)
template<class C >
C::const_iterator	SelectRandomWeightedContainerElement (C const &container, std::vector< double > weights)
template<class C , class Fn >
C::const_iterator	SelectRandomWeightedContainerElement (C const &container, Fn weightExtractor)
template<class Iterator1 , class Iterator2 >
bool	Intersects (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
template<class K , class V , template< class, class, class...> class M, class... Rest>
void	MultimapErasePair (M< K, V, Rest...> &multimap, K const &key, V const &value)

Function Documentation

template<class Iterator1 , class Iterator2 >

bool Trinity::Containers::Intersects	(	Iterator1	first1,
		Iterator1	last1,
		Iterator2	first2,
		Iterator2	last2
	)

 {
 while (first1 != last1 && first2 != last2)
 {
 if (*first1 < *first2)
 ++first1;
 else if (*first2 < *first1)
 ++first2;
 else
 return true;
 }

 return false;
 }

Here is the caller graph for this function:

template<class K , class V , template< class, class, class...> class M, class... Rest>

void Trinity::Containers::MultimapErasePair	(	M< K, V, Rest...> &	multimap,
		K const &	key,
		V const &	value
	)

 {
 auto range = multimap.equal_range(key);
 for (auto itr = range.first; itr != range.second;)
 {
 if (itr->second == value)
 itr = multimap.erase(itr);
 else
 ++itr;
 }
 }

Here is the caller graph for this function:

template<class T >

void Trinity::Containers::RandomResizeList	(	std::list< T > &	list,
		uint32	size
	)

 {
 uint32 list_size = uint32(list.size());

 while (list_size > size)
 {
 typename std::list<T>::iterator itr = list.begin();
 std::advance(itr, urand(0, list_size - 1));
 list.erase(itr);
 --list_size;
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Predicate >

void Trinity::Containers::RandomResizeList	(	std::list< T > &	list,
		Predicate &	predicate,
		uint32	size
	)

First use predicate filter

 {
 std::list<T> listCopy;
 for (typename std::list<T>::iterator itr = list.begin(); itr != list.end(); ++itr)
 if (predicate(*itr))
 listCopy.push_back(*itr);

 if (size)
 RandomResizeList(listCopy, size);

 list = listCopy;
 }

Here is the call graph for this function:

template<class C >

C::value_type const& Trinity::Containers::SelectRandomContainerElement

(

C const &

container

)

 {
 typename C::const_iterator it = container.begin();
 std::advance(it, urand(0, uint32(container.size()) - 1));
 return *it;
 }

Here is the call graph for this function:

template<class C >

C::const_iterator Trinity::Containers::SelectRandomWeightedContainerElement	(	C const &	container,
		std::vector< double >	weights
	)

 {
 Trinity::discrete_distribution_param<uint32> ddParam(weights.begin(), weights.end());
 std::discrete_distribution<uint32> dd(ddParam);
 typename C::const_iterator it = container.begin();
 std::advance(it, dd(SFMTEngine::Instance()));
 return it;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class C , class Fn >

C::const_iterator Trinity::Containers::SelectRandomWeightedContainerElement	(	C const &	container,
		Fn	weightExtractor
	)

 {
 std::vector<double> weights;
 weights.reserve(container.size());
 double weightSum = 0.0;
 for (auto itr = container.begin(); itr != container.end(); ++itr)
 {
 double weight = weightExtractor(*itr);
 weights.push_back(weight);
 weightSum += weight;
 }
 if (weightSum <= 0.0)
 weights.assign(container.size(), 1.0);

 return SelectRandomWeightedContainerElement(container, weights);
 }

Here is the call graph for this function: