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
154
155
156
157
158
159
160
|
#include "StarItemDescriptor.hpp"
#include "StarItem.hpp"
#include "StarRoot.hpp"
#include "StarVersioningDatabase.hpp"
namespace Star {
ItemDescriptor::ItemDescriptor() : m_count(0), m_parameters(JsonObject()) {}
ItemDescriptor::ItemDescriptor(String name, uint64_t count, Json parameters)
: m_name(std::move(name)), m_count(count), m_parameters(std::move(parameters)) {
if (m_parameters.isNull())
m_parameters = JsonObject();
if (!m_parameters.isType(Json::Type::Object))
throw StarException("Item parameters not map in ItemDescriptor constructor");
}
ItemDescriptor::ItemDescriptor(Json const& spec) {
if (spec.type() == Json::Type::Array) {
m_name = spec.getString(0);
m_count = spec.getInt(1, 1);
m_parameters = spec.getObject(2, {});
} else if (spec.type() == Json::Type::Object) {
if (spec.contains("name"))
m_name = spec.getString("name");
else if (spec.contains("item"))
m_name = spec.getString("item");
else
throw StarException("Item name missing.");
m_count = spec.getInt("count", 1);
m_parameters = spec.getObject("parameters", spec.getObject("data", JsonObject{}));
} else if (spec.type() == Json::Type::String) {
m_name = spec.toString();
m_count = 1;
m_parameters = JsonObject();
} else if (spec.isNull()) {
m_parameters = JsonObject();
m_count = 0;
} else {
throw ItemException("ItemDescriptor spec variant not list, map, string, or null");
}
}
ItemDescriptor ItemDescriptor::loadStore(Json const& spec) {
auto versioningDatabase = Root::singleton().versioningDatabase();
return ItemDescriptor{versioningDatabase->loadVersionedJson(VersionedJson::fromJson(spec), "Item")};
}
String const& ItemDescriptor::name() const {
return m_name;
}
uint64_t ItemDescriptor::count() const {
return m_count;
}
Json const& ItemDescriptor::parameters() const {
return m_parameters;
}
ItemDescriptor ItemDescriptor::singular() const {
return ItemDescriptor(name(), 1, parameters(), m_parametersHash);
}
ItemDescriptor ItemDescriptor::withCount(uint64_t count) const {
return ItemDescriptor(name(), count, parameters(), m_parametersHash);
}
ItemDescriptor ItemDescriptor::multiply(uint64_t count) const {
return ItemDescriptor(name(), this->count() * count, parameters(), m_parametersHash);
}
ItemDescriptor ItemDescriptor::applyParameters(JsonObject const& parameters) const {
return ItemDescriptor(name(), this->count(), this->parameters().setAll(parameters));
}
bool ItemDescriptor::isNull() const {
return m_name.empty();
}
ItemDescriptor::operator bool() const {
return !isNull();
}
bool ItemDescriptor::isEmpty() const {
return m_name.empty() || m_count == 0;
}
bool ItemDescriptor::operator==(ItemDescriptor const& rhs) const {
return std::tie(m_name, m_count, m_parameters) == std::tie(rhs.m_name, rhs.m_count, rhs.m_parameters);
}
bool ItemDescriptor::operator!=(ItemDescriptor const& rhs) const {
return std::tie(m_name, m_count, m_parameters) != std::tie(rhs.m_name, rhs.m_count, rhs.m_parameters);
}
bool ItemDescriptor::matches(ItemDescriptor const& other, bool exactMatch) const {
return other.name() == m_name && (!exactMatch || other.parameters() == m_parameters);
}
bool ItemDescriptor::matches(ItemConstPtr const& other, bool exactMatch) const {
return other->name() == m_name && (!exactMatch || other->parameters() == m_parameters);
}
Json ItemDescriptor::diskStore() const {
auto versioningDatabase = Root::singleton().versioningDatabase();
auto res = JsonObject{
{"name", m_name}, {"count", m_count}, {"parameters", m_parameters},
};
return versioningDatabase->makeCurrentVersionedJson("Item", res).toJson();
}
Json ItemDescriptor::toJson() const {
if (isNull()) {
return Json();
} else {
return JsonObject{
{"name", m_name}, {"count", m_count}, {"parameters", m_parameters},
};
}
}
ItemDescriptor::ItemDescriptor(String name, uint64_t count, Json parameters, Maybe<size_t> parametersHash)
: m_name(std::move(name)), m_count(count), m_parameters(std::move(parameters)), m_parametersHash(parametersHash) {}
size_t ItemDescriptor::parametersHash() const {
if (!m_parametersHash)
m_parametersHash = hash<Json>()(m_parameters);
return *m_parametersHash;
}
DataStream& operator>>(DataStream& ds, ItemDescriptor& itemDescriptor) {
ds.read(itemDescriptor.m_name);
ds.readVlqU(itemDescriptor.m_count);
ds.read(itemDescriptor.m_parameters);
itemDescriptor.m_parametersHash.reset();
return ds;
}
DataStream& operator<<(DataStream& ds, ItemDescriptor const& itemDescriptor) {
ds.write(itemDescriptor.m_name);
ds.writeVlqU(itemDescriptor.m_count);
ds.write(itemDescriptor.m_parameters);
return ds;
}
std::ostream& operator<<(std::ostream& os, ItemDescriptor const& descriptor) {
format(os, "[{}, {}, {}]", descriptor.m_name, descriptor.m_count, descriptor.m_parameters);
return os;
}
size_t hash<ItemDescriptor>::operator()(ItemDescriptor const& v) const {
return hashOf(v.m_name, v.m_count, v.m_parametersHash);
}
}
|