1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/*
* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
*
* 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 <functional>
#include <list>
#include <vector>
namespace Trinity
{
namespace Containers
{
template<class T>
void 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;
}
}
template<class T, class Predicate>
void 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;
}
/*
* Select a random element from a container.
*
* Note: container cannot be empty
*/
template <class C>
typename C::value_type const& SelectRandomContainerElement(C const& container)
{
typename C::const_iterator it = container.begin();
std::advance(it, urand(0, uint32(container.size()) - 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
*
* Note: container cannot be empty
*/
template <class C>
typename C::const_iterator 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;
}
/*
* 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
*
* Note: container cannot be empty
*/
template <class C>
typename C::const_iterator SelectRandomWeightedContainerElement(C const& container, std::function<double(typename C::value_type const&)> weightExtractor)
{
std::vector<double> weights;
weights.reserve(container.size());
std::transform(container.begin(), container.end(), std::back_inserter(weights), weightExtractor);
return SelectRandomWeightedContainerElement(container, weights);
}
/**
* @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>
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;
}
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)
{
auto range = multimap.equal_range(key);
for (auto itr = range.first; itr != range.second;)
{
if (itr->second == value)
itr = multimap.erase(itr);
else
++itr;
}
}
}
//! namespace Containers
}
//! namespace Trinity
#endif //! #ifdef TRINITY_CONTAINERS_H
|
