aboutsummaryrefslogtreecommitdiff
path: root/src/openvic/dataloader/NodeTools.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/openvic/dataloader/NodeTools.cpp')
-rw-r--r--src/openvic/dataloader/NodeTools.cpp115
1 files changed, 57 insertions, 58 deletions
diff --git a/src/openvic/dataloader/NodeTools.cpp b/src/openvic/dataloader/NodeTools.cpp
index 6e5f7d0..499527f 100644
--- a/src/openvic/dataloader/NodeTools.cpp
+++ b/src/openvic/dataloader/NodeTools.cpp
@@ -6,8 +6,8 @@ using namespace OpenVic;
using namespace OpenVic::NodeTools;
template<typename T>
-static node_callback_t _expect_type(std::function<return_t(T const&)> callback) {
- return [callback](ast::NodeCPtr node) -> return_t {
+static node_callback_t _expect_type(std::function<bool(T const&)> callback) {
+ return [callback](ast::NodeCPtr node) -> bool {
if (node != nullptr) {
T const* cast_node = node->cast_to<T>();
if (cast_node != nullptr) {
@@ -17,28 +17,28 @@ static node_callback_t _expect_type(std::function<return_t(T const&)> callback)
} else {
Logger::error("Null node when expecting ", T::get_type_static());
}
- return FAILURE;
+ return false;
};
}
template<typename T = ast::AbstractStringNode>
requires(std::derived_from<T, ast::AbstractStringNode>)
-static std::function<return_t(T const&)> abstract_string_node_callback(std::function<return_t(std::string_view)> callback) {
- return [callback](T const& node) -> return_t {
+static std::function<bool(T const&)> abstract_string_node_callback(std::function<bool(std::string_view)> callback) {
+ return [callback](T const& node) -> bool {
return callback(node._name);
};
}
-node_callback_t NodeTools::expect_identifier(std::function<return_t(std::string_view)> callback) {
+node_callback_t NodeTools::expect_identifier(std::function<bool(std::string_view)> callback) {
return _expect_type<ast::IdentifierNode>(abstract_string_node_callback<ast::IdentifierNode>(callback));
}
-node_callback_t NodeTools::expect_string(std::function<return_t(std::string_view)> callback) {
+node_callback_t NodeTools::expect_string(std::function<bool(std::string_view)> callback) {
return _expect_type<ast::StringNode>(abstract_string_node_callback<ast::StringNode>(callback));
}
-node_callback_t NodeTools::expect_identifier_or_string(std::function<return_t(std::string_view)> callback) {
- return [callback](ast::NodeCPtr node) -> return_t {
+node_callback_t NodeTools::expect_identifier_or_string(std::function<bool(std::string_view)> callback) {
+ return [callback](ast::NodeCPtr node) -> bool {
if (node != nullptr) {
ast::AbstractStringNode const* cast_node = node->cast_to<ast::IdentifierNode>();
if (cast_node == nullptr) {
@@ -51,109 +51,108 @@ node_callback_t NodeTools::expect_identifier_or_string(std::function<return_t(st
} else {
Logger::error("Null node when expecting ", ast::IdentifierNode::get_type_static(), " or ", ast::StringNode::get_type_static());
}
- return FAILURE;
+ return false;
};
}
-node_callback_t NodeTools::expect_bool(std::function<return_t(bool)> callback) {
+node_callback_t NodeTools::expect_bool(std::function<bool(bool)> callback) {
return expect_identifier(
- [callback](std::string_view identifier) -> return_t {
+ [callback](std::string_view identifier) -> bool {
if (identifier == "yes") {
return callback(true);
} else if (identifier == "no") {
return callback(false);
}
Logger::error("Invalid bool identifier text: ", identifier);
- return FAILURE;
+ return false;
}
);
}
-node_callback_t NodeTools::expect_int(std::function<return_t(int64_t)> callback) {
+node_callback_t NodeTools::expect_int(std::function<bool(int64_t)> callback) {
return expect_identifier(
- [callback](std::string_view identifier) -> return_t {
+ [callback](std::string_view identifier) -> bool {
bool successful = false;
const int64_t val = StringUtils::string_to_int64(identifier, &successful, 10);
if (successful) {
return callback(val);
}
Logger::error("Invalid int identifier text: ", identifier);
- return FAILURE;
+ return false;
}
);
}
-node_callback_t NodeTools::expect_uint(std::function<return_t(uint64_t)> callback) {
+node_callback_t NodeTools::expect_uint(std::function<bool(uint64_t)> callback) {
return expect_identifier(
- [callback](std::string_view identifier) -> return_t {
+ [callback](std::string_view identifier) -> bool {
bool successful = false;
const uint64_t val = StringUtils::string_to_uint64(identifier, &successful, 10);
if (successful) {
return callback(val);
}
Logger::error("Invalid uint identifier text: ", identifier);
- return FAILURE;
+ return false;
}
);
}
-node_callback_t NodeTools::expect_fixed_point(std::function<return_t(FP)> callback) {
+node_callback_t NodeTools::expect_fixed_point(std::function<bool(FP)> callback) {
return expect_identifier(
- [callback](std::string_view identifier) -> return_t {
+ [callback](std::string_view identifier) -> bool {
bool successful = false;
const FP val = FP::parse(identifier.data(), identifier.length(), &successful);
if (successful) {
return callback(val);
}
Logger::error("Invalid fixed point identifier text: ", identifier);
- return FAILURE;
+ return false;
}
);
}
-node_callback_t NodeTools::expect_colour(std::function<return_t(colour_t)> callback) {
- return [callback](ast::NodeCPtr node) -> return_t {
+node_callback_t NodeTools::expect_colour(std::function<bool(colour_t)> callback) {
+ return [callback](ast::NodeCPtr node) -> bool {
colour_t col = NULL_COLOUR;
uint32_t components = 0;
- return_t ret = expect_list_of_length(3,
+ bool ret = expect_list_of_length(3,
expect_fixed_point(
- [&col, &components](FP val) -> return_t {
- return_t ret = SUCCESS;
+ [&col, &components](FP val) -> bool {
+ components++;
+ col <<= 8;
if (val < 0 || val > 255) {
Logger::error("Invalid colour component: ", val);
- val = FP::_0();
- ret = FAILURE;
+ return false;
+ } else {
+ if (val <= 1) val *= 255;
+ col |= val.to_int32_t();
+ return true;
}
- if (val <= 1) val *= 255;
- col = (col << 8) | val.to_int32_t();
- components++;
- return ret;
}
)
)(node);
- if (components < 3) col <<= 8 * (3 - components);
- if (callback(col) != SUCCESS) ret = FAILURE;
+ ret &= callback(col << 8 * (3 - components));
return ret;
};
}
-node_callback_t NodeTools::expect_date(std::function<return_t(Date)> callback) {
+node_callback_t NodeTools::expect_date(std::function<bool(Date)> callback) {
return expect_identifier(
- [callback](std::string_view identifier) -> return_t {
+ [callback](std::string_view identifier) -> bool {
bool successful = false;
const Date date = Date::from_string(identifier, &successful);
if (successful) {
return callback(date);
}
Logger::error("Invalid date identifier text: ", identifier);
- return FAILURE;
+ return false;
}
);
}
node_callback_t NodeTools::expect_assign(key_value_callback_t callback) {
return _expect_type<ast::AssignNode>(
- [callback](ast::AssignNode const& assign_node) -> return_t {
+ [callback](ast::AssignNode const& assign_node) -> bool {
return callback(assign_node._name, assign_node._initializer.get());
}
);
@@ -161,18 +160,18 @@ node_callback_t NodeTools::expect_assign(key_value_callback_t callback) {
node_callback_t NodeTools::expect_list_and_length(length_callback_t length_callback, node_callback_t callback) {
return _expect_type<ast::AbstractListNode>(
- [length_callback, callback](ast::AbstractListNode const& list_node) -> return_t {
+ [length_callback, callback](ast::AbstractListNode const& list_node) -> bool {
std::vector<ast::NodeUPtr> const& list = list_node._statements;
- return_t ret = SUCCESS;
+ bool ret = true;
size_t size = length_callback(list.size());
if (size > list.size()) {
Logger::error("Trying to read more values than the list contains: ", size, " > ", list.size());
size = list.size();
- ret = FAILURE;
+ ret = false;
}
std::for_each(list.begin(), list.begin() + size,
[callback, &ret](ast::NodeUPtr const& sub_node) -> void {
- if (callback(sub_node.get()) != SUCCESS) ret = FAILURE;
+ ret &= callback(sub_node.get());
}
);
return ret;
@@ -181,19 +180,19 @@ node_callback_t NodeTools::expect_list_and_length(length_callback_t length_callb
}
node_callback_t NodeTools::expect_list_of_length(size_t length, node_callback_t callback) {
- return [length, callback](ast::NodeCPtr node) -> return_t {
- return_t ret = SUCCESS;
- if (expect_list_and_length(
+ return [length, callback](ast::NodeCPtr node) -> bool {
+ bool ret = true;
+ ret &= expect_list_and_length(
[length, &ret](size_t size) -> size_t {
if (size != length) {
Logger::error("List length ", size, " does not match expected length ", length);
- ret = FAILURE;
+ ret = false;
if (length < size) return length;
}
return size;
},
callback
- )(node) != SUCCESS) ret = FAILURE;
+ )(node);
return ret;
};
}
@@ -211,20 +210,20 @@ node_callback_t NodeTools::expect_dictionary(key_value_callback_t callback) {
}
node_callback_t NodeTools::_expect_dictionary_keys_and_length(length_callback_t length_callback, bool allow_other_keys, key_map_t&& key_map) {
- return [length_callback, allow_other_keys, key_map = std::move(key_map)](ast::NodeCPtr node) mutable -> return_t {
- return_t ret = expect_dictionary_and_length(
+ return [length_callback, allow_other_keys, key_map = std::move(key_map)](ast::NodeCPtr node) mutable -> bool {
+ bool ret = expect_dictionary_and_length(
length_callback,
- [&key_map, allow_other_keys](std::string_view key, ast::NodeCPtr value) -> return_t {
+ [&key_map, allow_other_keys](std::string_view key, ast::NodeCPtr value) -> bool {
const key_map_t::iterator it = key_map.find(key);
if (it == key_map.end()) {
- if (allow_other_keys) return SUCCESS;
+ if (allow_other_keys) return true;
Logger::error("Invalid dictionary key: ", key);
- return FAILURE;
+ return false;
}
dictionary_entry_t& entry = it->second;
if (++entry.count > 1 && !entry.can_repeat()) {
Logger::error("Invalid repeat of dictionary key: ", key);
- return FAILURE;
+ return false;
}
return entry.callback(value);
}
@@ -233,7 +232,7 @@ node_callback_t NodeTools::_expect_dictionary_keys_and_length(length_callback_t
dictionary_entry_t const& entry = key_entry.second;
if (entry.must_appear() && entry.count < 1) {
Logger::error("Mandatory dictionary key not present: ", key_entry.first);
- ret = FAILURE;
+ ret = false;
}
}
return ret;
@@ -244,13 +243,13 @@ node_callback_t NodeTools::name_list_callback(std::vector<std::string>& list) {
return expect_list_reserve_length(
list,
expect_identifier_or_string(
- [&list](std::string_view str) -> return_t {
+ [&list](std::string_view str) -> bool {
if (!str.empty()) {
list.push_back(std::string { str });
- return SUCCESS;
+ return true;
}
Logger::error("Empty identifier or string");
- return FAILURE;
+ return false;
}
)
);
generated by our cgit fork (git 2.39.0) at 2024-01-23 02:24:14 +0100