282 lines
10 KiB
C++
282 lines
10 KiB
C++
/*
|
|
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
|
|
*
|
|
* This program 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 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef TRINITY_CONTAINERS_H
|
|
#define TRINITY_CONTAINERS_H
|
|
|
|
#include "Define.h"
|
|
#include "Random.h"
|
|
#include <algorithm>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace Trinity
|
|
{
|
|
template<class T>
|
|
constexpr inline T* AddressOrSelf(T* ptr)
|
|
{
|
|
return ptr;
|
|
}
|
|
|
|
template<class T>
|
|
constexpr inline T* AddressOrSelf(T& not_ptr)
|
|
{
|
|
return std::addressof(not_ptr);
|
|
}
|
|
|
|
namespace Containers
|
|
{
|
|
// replace with std::size in C++17
|
|
template<class C>
|
|
constexpr inline std::size_t Size(C const& container)
|
|
{
|
|
return container.size();
|
|
}
|
|
|
|
template<class T, std::size_t size>
|
|
constexpr inline std::size_t Size(T const(&)[size]) noexcept
|
|
{
|
|
return size;
|
|
}
|
|
|
|
// resizes <container> to have at most <requestedSize> elements
|
|
// if it has more than <requestedSize> elements, the elements to keep are selected randomly
|
|
template<class C>
|
|
void RandomResize(C& container, std::size_t requestedSize)
|
|
{
|
|
static_assert(std::is_base_of<std::forward_iterator_tag, typename std::iterator_traits<typename C::iterator>::iterator_category>::value, "Invalid container passed to Trinity::Containers::RandomResize");
|
|
if (Size(container) <= requestedSize)
|
|
return;
|
|
auto keepIt = std::begin(container), curIt = std::begin(container);
|
|
uint32 elementsToKeep = requestedSize, elementsToProcess = Size(container);
|
|
while (elementsToProcess)
|
|
{
|
|
// this element has chance (elementsToKeep / elementsToProcess) of being kept
|
|
if (urand(1, elementsToProcess) <= elementsToKeep)
|
|
{
|
|
if (keepIt != curIt)
|
|
*keepIt = std::move(*curIt);
|
|
++keepIt;
|
|
--elementsToKeep;
|
|
}
|
|
++curIt;
|
|
--elementsToProcess;
|
|
}
|
|
container.erase(keepIt, std::end(container));
|
|
}
|
|
|
|
template<class C, class Predicate>
|
|
void RandomResize(C& container, Predicate&& predicate, std::size_t requestedSize)
|
|
{
|
|
//! First use predicate filter
|
|
C containerCopy;
|
|
std::copy_if(std::begin(container), std::end(container), std::inserter(containerCopy, std::end(containerCopy)), predicate);
|
|
|
|
if (requestedSize)
|
|
RandomResize(containerCopy, requestedSize);
|
|
|
|
container = std::move(containerCopy);
|
|
}
|
|
|
|
/*
|
|
* Select a random element from a container.
|
|
*
|
|
* Note: container cannot be empty
|
|
*/
|
|
template<class C>
|
|
inline auto SelectRandomContainerElement(C const& container) -> typename std::add_const<decltype(*std::begin(container))>::type&
|
|
{
|
|
auto it = std::begin(container);
|
|
std::advance(it, urand(0, uint32(Size(container)) - 1));
|
|
return *it;
|
|
}
|
|
|
|
/*
|
|
* Select a random element from a container where each element has a different chance to be selected.
|
|
*
|
|
* @param container Container to select an element from
|
|
* @param weights Chances of each element to be selected, must be in the same order as elements in container.
|
|
* Caller is responsible for checking that sum of all weights is greater than 0.
|
|
*
|
|
* Note: container cannot be empty
|
|
*/
|
|
template<class C>
|
|
inline auto SelectRandomWeightedContainerElement(C const& container, std::vector<double> const& weights) -> decltype(std::begin(container))
|
|
{
|
|
auto it = std::begin(container);
|
|
std::advance(it, urandweighted(weights.size(), weights.data()));
|
|
return it;
|
|
}
|
|
|
|
/*
|
|
* Select a random element from a container where each element has a different chance to be selected.
|
|
*
|
|
* @param container Container to select an element from
|
|
* @param weightExtractor Function retrieving chance of each element in container, expected to take an element of the container and returning a double
|
|
*
|
|
* Note: container cannot be empty
|
|
*/
|
|
template<class C, class Fn>
|
|
inline auto SelectRandomWeightedContainerElement(C const& container, Fn weightExtractor) -> decltype(std::begin(container))
|
|
{
|
|
std::vector<double> weights;
|
|
weights.reserve(Size(container));
|
|
double weightSum = 0.0;
|
|
for (auto& val : container)
|
|
{
|
|
double weight = weightExtractor(val);
|
|
weights.push_back(weight);
|
|
weightSum += weight;
|
|
}
|
|
if (weightSum <= 0.0)
|
|
weights.assign(Size(container), 1.0);
|
|
|
|
return SelectRandomWeightedContainerElement(container, weights);
|
|
}
|
|
|
|
/**
|
|
* @fn void Trinity::Containers::RandomShuffle(C& container)
|
|
*
|
|
* @brief Reorder the elements of the container randomly.
|
|
*
|
|
* @param container Container to reorder
|
|
*/
|
|
template<class C>
|
|
inline void RandomShuffle(C& container)
|
|
{
|
|
std::shuffle(std::begin(container), std::end(container), SFMTEngine::Instance());
|
|
}
|
|
|
|
/**
|
|
* @fn bool Trinity::Containers::Intersects(Iterator first1, Iterator last1, Iterator first2, Iterator last2)
|
|
*
|
|
* @brief Checks if two SORTED containers have a common element
|
|
*
|
|
* @param first1 Iterator pointing to start of the first container
|
|
* @param last1 Iterator pointing to end of the first container
|
|
* @param first2 Iterator pointing to start of the second container
|
|
* @param last2 Iterator pointing to end of the second container
|
|
*
|
|
* @return true if containers have a common element, false otherwise.
|
|
*/
|
|
template<class Iterator1, class Iterator2>
|
|
inline bool 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;
|
|
}
|
|
|
|
/**
|
|
* @fn bool Trinity::Containers::Intersects(Iterator first1, Iterator last1, Iterator first2, Iterator last2, Predicate&& equalPred)
|
|
*
|
|
* @brief Checks if two SORTED containers have a common element
|
|
*
|
|
* @param first1 Iterator pointing to start of the first container
|
|
* @param last1 Iterator pointing to end of the first container
|
|
* @param first2 Iterator pointing to start of the second container
|
|
* @param last2 Iterator pointing to end of the second container
|
|
* @param equalPred Additional predicate to exclude elements
|
|
*
|
|
* @return true if containers have a common element, false otherwise.
|
|
*/
|
|
template<class Iterator1, class Iterator2, class Predicate>
|
|
inline bool Intersects(Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2, Predicate&& equalPred)
|
|
{
|
|
while (first1 != last1 && first2 != last2)
|
|
{
|
|
if (*first1 < *first2)
|
|
++first1;
|
|
else if (*first2 < *first1)
|
|
++first2;
|
|
else if (!equalPred(*first1, *first2))
|
|
++first1, ++first2;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a pointer to mapped value (or the value itself if map stores pointers)
|
|
*/
|
|
template<class M>
|
|
inline auto MapGetValuePtr(M& map, typename M::key_type const& key) -> decltype(AddressOrSelf(map.find(key)->second))
|
|
{
|
|
auto itr = map.find(key);
|
|
return itr != map.end() ? AddressOrSelf(itr->second) : nullptr;
|
|
}
|
|
|
|
template<class K, class V, template<class, class, class...> class M, class... Rest>
|
|
inline void 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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a mutable reference to element at index i
|
|
* Will resize vector if neccessary to ensure element at i can be safely written
|
|
*
|
|
* This exists as separate overload instead of one function with default argument to allow using
|
|
* with vectors of non-default-constructible classes
|
|
*/
|
|
template<typename T>
|
|
inline decltype(auto) EnsureWritableVectorIndex(std::vector<T>& vec, typename std::vector<T>::size_type i)
|
|
{
|
|
if (i >= vec.size())
|
|
vec.resize(i + 1);
|
|
|
|
return vec[i];
|
|
}
|
|
|
|
/**
|
|
* Returns a mutable reference to element at index i
|
|
* Will resize vector if neccessary to ensure element at i can be safely written
|
|
*
|
|
* This overload allows specifying what value to pad vector with during .resize
|
|
*/
|
|
template<typename T>
|
|
inline decltype(auto) EnsureWritableVectorIndex(std::vector<T>& vec, typename std::vector<T>::size_type i, T const& resizeDefault)
|
|
{
|
|
if (i >= vec.size())
|
|
vec.resize(i + 1, resizeDefault);
|
|
|
|
return vec[i];
|
|
}
|
|
}
|
|
//! namespace Containers
|
|
}
|
|
//! namespace Trinity
|
|
|
|
#endif //! #ifdef TRINITY_CONTAINERS_H
|