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
|
/*
* BonusList.h, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#pragma once
#include "Bonus.h"
#include "BonusSelector.h"
VCMI_LIB_NAMESPACE_BEGIN
class DLL_LINKAGE BonusList
{
public:
using TInternalContainer = boost::container::small_vector<std::shared_ptr<Bonus>, 16>;
private:
TInternalContainer bonuses;
public:
using const_reference = TInternalContainer::const_reference;
using value_type = TInternalContainer::value_type;
using const_iterator = TInternalContainer::const_iterator;
using iterator = TInternalContainer::iterator;
BonusList() = default;
// wrapper functions of the STL vector container
TInternalContainer::size_type size() const { return bonuses.size(); }
void push_back(const std::shared_ptr<Bonus> & x);
TInternalContainer::iterator erase (const int position);
void clear();
bool empty() const { return bonuses.empty(); }
void resize(TInternalContainer::size_type sz, const std::shared_ptr<Bonus> & c = nullptr);
TInternalContainer::size_type capacity() const { return bonuses.capacity(); }
STRONG_INLINE std::shared_ptr<Bonus> &operator[] (TInternalContainer::size_type n) { return bonuses[n]; }
STRONG_INLINE const std::shared_ptr<Bonus> &operator[] (TInternalContainer::size_type n) const { return bonuses[n]; }
std::shared_ptr<Bonus> &back() { return bonuses.back(); }
std::shared_ptr<Bonus> &front() { return bonuses.front(); }
const std::shared_ptr<Bonus> &back() const { return bonuses.back(); }
const std::shared_ptr<Bonus> &front() const { return bonuses.front(); }
// There should be no non-const access to provide solid,robust bonus caching
TInternalContainer::const_iterator begin() const { return bonuses.begin(); }
TInternalContainer::const_iterator end() const { return bonuses.end(); }
TInternalContainer::size_type operator-=(const std::shared_ptr<Bonus> & i);
// BonusList functions
void stackBonuses();
int totalValue(int baseValue = 0) const;
void getBonuses(BonusList &out, const CSelector &selector, const CSelector &limit = nullptr) const;
void getAllBonuses(BonusList &out) const;
//special find functions
std::shared_ptr<Bonus> getFirst(const CSelector &select);
std::shared_ptr<const Bonus> getFirst(const CSelector &select) const;
int valOfBonuses(const CSelector &select, int baseValue = 0) const;
// conversion / output
JsonNode toJsonNode() const;
// remove_if implementation for STL vector types
template <class Predicate>
void remove_if(Predicate pred)
{
BonusList newList;
for(const auto & b : bonuses)
{
if (!pred(b.get()))
newList.push_back(b);
}
bonuses.clear();
bonuses.resize(newList.size());
std::copy(newList.begin(), newList.end(), bonuses.begin());
}
template <class InputIterator>
void insert(const int position, InputIterator first, InputIterator last);
void insert(TInternalContainer::iterator position, TInternalContainer::size_type n, const std::shared_ptr<Bonus> & x);
template <typename Handler>
void serialize(Handler &h)
{
h & static_cast<TInternalContainer&>(bonuses);
}
// C++ for range support
auto begin () -> decltype (bonuses.begin())
{
return bonuses.begin();
}
auto end () -> decltype (bonuses.end())
{
return bonuses.end();
}
};
DLL_LINKAGE std::ostream & operator<<(std::ostream &out, const BonusList &bonusList);
VCMI_LIB_NAMESPACE_END
|
