130 lines
3.8 KiB
C++
130 lines
3.8 KiB
C++
#include <sstream>
|
|
#include <algorithm>
|
|
#include <unordered_set>
|
|
|
|
#include <libreborn/log.h>
|
|
#include <libreborn/flags.h>
|
|
#include <libreborn/util.h>
|
|
|
|
// All Flags
|
|
static unsigned int find_indent_level(std::string &str) {
|
|
constexpr unsigned int INDENT = 4;
|
|
unsigned int count = 0;
|
|
for (const char c : str) {
|
|
if (c == ' ') {
|
|
count++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
str = str.substr(count);
|
|
return count / INDENT;
|
|
}
|
|
Flags::Flags(const std::string &data) {
|
|
FlagNode::reset_id_counter();
|
|
// Read Lines
|
|
std::stringstream stream(data);
|
|
std::string line;
|
|
std::vector stack = {&root};
|
|
while (std::getline(stream, line)) {
|
|
if (!line.empty()) {
|
|
// Get Parent
|
|
const unsigned int indent = find_indent_level(line);
|
|
if (indent >= stack.size()) {
|
|
ERR("Bad Feature Flag Indent: %s", line.c_str());
|
|
}
|
|
stack.resize(indent + 1);
|
|
FlagNode &parent = *stack.back();
|
|
// Add New Node
|
|
if (FlagNode::handle_line_prefix("CATEGORY", line)) {
|
|
// New Category
|
|
FlagNode &category = parent.add_category(line);
|
|
stack.push_back(&category);
|
|
} else {
|
|
// Add Flag
|
|
if (indent == 0) {
|
|
ERR("Feature Flag Outside Of Category: %s", line.c_str());
|
|
}
|
|
parent.add_flag(line);
|
|
}
|
|
}
|
|
}
|
|
// Sort
|
|
root.sort();
|
|
// Check For Duplicates
|
|
std::unordered_set<std::string> seen;
|
|
root.for_each_const([&seen](const FlagNode &node) {
|
|
const std::string &name = node.name;
|
|
if (seen.contains(name)) {
|
|
ERR("Duplicate Feature Flag: %s", name.c_str());
|
|
} else {
|
|
seen.insert(name);
|
|
}
|
|
});
|
|
}
|
|
std::string Flags::to_string() const {
|
|
std::string out;
|
|
root.for_each_const([&out](const FlagNode &flag) {
|
|
if (flag.value) {
|
|
if (!out.empty()) {
|
|
out += FLAG_SEPERATOR_CHAR;
|
|
}
|
|
out += flag.name;
|
|
}
|
|
});
|
|
return out;
|
|
}
|
|
void Flags::from_string(const std::string &str) {
|
|
// Find Flags To Enable
|
|
std::unordered_set<std::string> to_enable;
|
|
std::stringstream stream(str);
|
|
std::string flag_name;
|
|
while (std::getline(stream, flag_name, FLAG_SEPERATOR_CHAR)) {
|
|
if (!flag_name.empty()) {
|
|
to_enable.insert(flag_name);
|
|
}
|
|
}
|
|
// Update Flags
|
|
root.for_each([&to_enable](FlagNode &flag) {
|
|
flag.value = to_enable.contains(flag.name);
|
|
});
|
|
}
|
|
bool Flags::operator==(const Flags &other) const {
|
|
return to_string() == other.to_string();
|
|
}
|
|
std::unordered_map<std::string, bool> Flags::to_cache() const {
|
|
std::unordered_map<std::string, bool> out;
|
|
root.for_each_const([&out](const FlagNode &flag) {
|
|
out[flag.name] = flag.value;
|
|
});
|
|
return out;
|
|
}
|
|
void Flags::from_cache(const std::unordered_map<std::string, bool> &cache) {
|
|
root.for_each([&cache](FlagNode &flag) {
|
|
if (cache.contains(flag.name)) {
|
|
flag.value = cache.at(flag.name);
|
|
}
|
|
});
|
|
}
|
|
void Flags::print() const {
|
|
root.for_each_const([](const FlagNode &flag) {
|
|
std::string prefix;
|
|
for (const std::pair<const std::string, bool> &it : FlagNode::flag_prefixes) {
|
|
if (it.second == flag.value) {
|
|
prefix = it.first;
|
|
break;
|
|
}
|
|
}
|
|
if (prefix.empty()) {
|
|
IMPOSSIBLE();
|
|
}
|
|
printf("%s %s\n", prefix.c_str(), flag.name.c_str());
|
|
fflush(stdout);
|
|
});
|
|
}
|
|
|
|
// Instance
|
|
EMBEDDED_RESOURCE(available_feature_flags);
|
|
Flags Flags::get() {
|
|
return Flags(std::string(available_feature_flags, available_feature_flags + available_feature_flags_len));
|
|
} |