I am trying to make a YamlConfig class with yaml-cpp. One of its main features is that, in the style of Bukkit, a Minecaft API, its users can easily reference different nodes in a tree of maps (e.g. a map that contains maps that contains maps, but to varying depths) via a string like "map1.map2.map3.keyoffinalvalue". I wrote the seek function in the following minimal example to do it, but even though it is marked const, the string that is printed out each time it is invoked is different and seems to be just the map that contains the final value on the previous invocation. This demonstrates a problem that m_rootNode seems to be changing. What is going on?
Originally, this function wasn't const (and I will need to make it non-const after debugging) and I thought that due to horrific API design that YAML::Node acted like some sort of reference instead of a well-behaved value-like type as is standard in C++ (surprising the user of an API is generally horrific API design). But, that is not consistent with the function being marked const. As such, I now have no idea what is going on. I tried to find similar issues via my search engine as well, but nothing that came up was remotely relevant beyond just being part of the same YAML library.
#include <yaml-cpp/yaml.h>
#include <string>
#include <string_view>
#include <vector>
#include <iostream>
class YamlConfig{
public:
YamlConfig(const std::string &yaml);
YAML::Node seek(std::string_view key, bool create) const;
private:
YAML::Node m_rootNode;
static std::vector<std::string> split(std::string_view input, char delimeter);
};
YamlConfig::YamlConfig(const std::string &yaml){
m_rootNode = YAML::Load(yaml);
}
YAML::Node YamlConfig::seek(std::string_view key, bool create) const {
auto splitKey = split(key, '.');
YAML::Node current = m_rootNode;
YAML::Emitter emitter;
emitter << current;
std::cout << emitter.c_str() << std::endl;
for(const auto &keySegment : splitKey){
if(current.IsMap()){
current = current[keySegment];
if( (!current) && (!create) ){
throw std::runtime_error("Invalid YAML key due to attempting to descend in to non-existent node: " + keySegment);
}
}else{
throw std::runtime_error("Invalid YAML key due to attempting to descend in to non-map node: " + std::string(key));
}
}
return current;
}
std::vector<std::string> YamlConfig::split(std::string_view input, char delimeter) {
std::vector<std::string> output;
auto baseit = input.begin();
for(auto it=input.begin();it!=input.end();++it){
if(*it == delimeter){
output.emplace_back(baseit, it);
baseit = it+1;
if(*baseit == delimeter){
throw std::invalid_argument("Double delimiter found in string \"" + std::string(input) + "\"");
}
}
}
output.emplace_back(baseit, input.end());
return output;
}
int main(){
const std::string yaml = "engine:\n view-distance: 16\n fullscreen: false\n";
std::cout << yaml << std::endl;
YamlConfig yamlConfig(yaml);
std::cout << yamlConfig.seek("engine.view-distance", false).as<std::string>() << std::endl;
std::cout << yamlConfig.seek("engine.view-distance", false).as<std::string>() << std::endl;
return 0;
}
This code, when compiled, produces the following output without my comments:
engine: //this is the printout of the string in main
view-distance: 16
fullscreen: false
engine: //this is the first printout of the root node, good
view-distance: 16
fullscreen: false
16 //this is the printout of the value that was retrieved from the yaml data
view-distance: 16 //This is the second printout of the "root" node. It looks like the root node is now the engine node, changed via a const function What is going on?
fullscreen: false
terminate called after throwing an instance of 'std::runtime_error' //this is an artifact of the root node seemingly changing, and is consistent with it changing to be the engine node
what(): Invalid YAML key due to attempting to descend in to non-existent node: engine
Aborted (core dumped)
Compile command:
clang++ --std=c++17 -lyaml-cpp yaml.cpp -o yaml
A quick look at the API reveals these lines:
mutable detail::shared_memory_holder m_pMemory;
mutable detail::node* m_pNode;
The mutable modifier tells us that even a const function on this node may change these values. That is concerning, but actually not the problem. As we can see, YAML::Node is only a reference to the actual node. Digging further, we find the implementation of the assignment operator:
inline Node& Node::operator=(const Node& rhs) {
if (is(rhs))
return *this;
AssignNode(rhs);
return *this;
}
/* snip */
inline void Node::AssignNode(const Node& rhs) {
if (!m_isValid)
throw InvalidNode(m_invalidKey);
rhs.EnsureNodeExists();
if (!m_pNode) {
m_pNode = rhs.m_pNode;
m_pMemory = rhs.m_pMemory;
return;
}
m_pNode->set_ref(*rhs.m_pNode);
m_pMemory->merge(*rhs.m_pMemory);
m_pNode = rhs.m_pNode;
}
So as we can see, assigning a YAML::Node will modify the referenced node which is your problem. This works even though your function is const since you can still modify the referenced data from a const pointer.
The question is, how is the API supposed to be used? I don't really know. the operator[] returns a value, not a reference, so you cannot use pointers; and there is no find function which would return an iterator that could be used.
A, admittedly horrible, workaround would be:
auto tmp = current[keySegment]; // get next node
current.~Node(); // destruct node reference (not the referenced node)
new (¤t) Node(tmp); // call copy constructor with placement new to assign
// tmp to current. necessary since current is invalid at this point.
Alternatively, you could implement seek recursively to avoid re-assigning current.