How to store a string from YAML::Node in a class using template decoding

Question

I have been trying to implement some convert structs for yaml-cpp for my own data types. Of which one is a class, not just a struct. The encode function works fine. But the decode function doesn't. I try to get a string from a yaml file and set the correct variable in the class.

template<>
struct convert<EngineNode*> {
  static Node encode(EngineNode *rhs) {
    Node node;
    std::string type;
    if(rhs->type == 0) {
        type = "node";
    } else if(rhs->type == 1) {
        type = "scene";
    } else if(rhs->type == 3) {
        type = "particle";
    }
    node[type]["name"] = rhs->name;
    node[type]["type"] = rhs->type;
    node[type]["velocity"] = rhs->getVelocity();
    node[type]["position"] = rhs->getPosition();
    node[type]["rotation"] = rhs->getRotation();

    for(unsigned i = 0; i < rhs->children.size(); i++) {
        if(rhs->children[i]->type == SPRITE) {
            node[type]["children"].push_back((SpriteNode*)rhs->children[i]);
        } else {
            node[type]["children"].push_back(rhs->children[i]);
        }
    }
    return node;
  }

  static bool decode(const Node& node, EngineNode *rhs) {
    if((!node["root"]["node"].IsDefined()) && (!node["root"]["scene"].IsDefined()) && (!node["particle"].IsDefined())) {
        return false;
    }
    std::string type;

    if(node["root"]["node"].IsDefined()) {
        type = "node";       
    } else if(node["root"]["scene"].IsDefined()) {
        type = "scene";
    }
    const Node n = node["root"][type];

    rhs->name = n["name"].as<std::string>();
    rhs->type = n["type"].as<int>();
    rhs->setVelocity(n["velocity"].as<Velocity>());
    rhs->setPosition(n["position"].as<Point>());
    rhs->setRotation(n["rotation"].as<float>());

    for(unsigned i = 0; i < n["children"].size(); i++) {
        if(n["children"]["type"].as<int>() == SPRITE) {
            rhs->addChild(n["children"].as<SpriteNode*>());
        } else {
            rhs->addChild(n["children"].as<EngineNode*>());
        }
    }

    return true;
  }
};

If you want to look at the full source its at github.

The problem is that it segfaults with the following error:

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff73e3b5c in std::string::assign(std::string const&) () from /usr/lib/libstdc++.so.6
(gdb) bt
#0  0x00007ffff73e3b5c in std::string::assign(std::string const&) () from /usr/lib/libstdc++.so.6
#1  0x000000000040f590 in YAML::convert<EngineNode*>::decode (node=..., rhs=0x8) at src/yaml_config.cpp:90
#2  0x000000000040ef9f in YAML::as_if<EngineNode*, void>::operator() (this=0x7fffffffe4c0) at /usr/include/yaml-cpp/node/impl.h:119
#3  0x0000000000407a7d in YAML::Node::as<EngineNode*> (this=0x7fffffffe5c8) at /usr/include/yaml-cpp/node/impl.h:143
#4  0x00000000004074f9 in YamlConfig::readNode (this=0x8cf810, yaml_node=...) at src/yaml_config.cpp:172
#5  0x000000000040739a in YamlConfig::read (this=0x8cf810, path=...) at src/yaml_config.cpp:161
#6  0x0000000000404fa5 in GameScene::GameScene (this=0x8d62d0) at game/gamescene.cpp:16
#7  0x0000000000404205 in Main::initGameScene (this=0x61d2b0) at src/main.cpp:75
#8  0x0000000000404480 in main () at src/main.cpp:145

I can't figure out why that happens, it's probably not related to yaml-cpp at all but just my very limited understanding of templates and other stuff that's used here. (I only know very basic c++)

Any help would be appreciated,

Peter

From the backtrace, it looks like the rhs pointer was at address 0x8 when decode was called. That's probably not a valid address. Are you sure rhs was allocated correctly before passing it to the YAML decoder? — Austin Mullins
– Austin Mullins, Commented Mar 9, 2015 at 18:44
Line 90 is the line with rhs->name = n["name"].as<std::string>(); I have no idea where or how rhs should be allocated, so yeah, that's probably the problem. I thought about that, but I don't know where I should allocated it. In the decode function? — blackwolf123333
– blackwolf123333, Commented Mar 9, 2015 at 18:49
It would only work there if you could pass a pointer to the pointer, since you would get a pointer back from the new operator, and that would then need to be passed back to the caller. I would rather have the caller allocate the rhs like they do for the encode function. — Austin Mullins
– Austin Mullins, Commented Mar 9, 2015 at 18:57

Austin Mullins · Accepted Answer · 2015-03-09 20:27:44Z

1

The problem is that the Node::as<T> function allocates a variable of type T on the stack and then uses copy semantics to return the converted value. In the above case, T is EngineNode *, which is a pointer to an EngineNode. The as function does not allocate additional memory for an actual EngineNode, so dereferencing (using * or ->) results in a segmentation fault.

The fix would be to rework your conversion functions to use references instead of pointers:

template<>
struct convert<EngineNode> {
  static Node encode(const EngineNode &rhs) {
    Node node;
    std::string type;
    if(rhs.type == 0) {
        type = "node";
    } else if(rhs.type == 1) {
        type = "scene";
    } else if(rhs.type == 3) {
        type = "particle";
    }    

    // ...
  }

  static bool decode(const Node& node, EngineNode &rhs) {
    if((!node["root"]["node"].IsDefined()) && (!node["root"]["scene"].IsDefined()) && (!node["particle"].IsDefined())) {
    return false;
    }
    std::string type;

    if(node["root"]["node"].IsDefined()) {
        type = "node";       
    } else if(node["root"]["scene"].IsDefined()) {
        type = "scene";
    }
    const Node n = node["root"][type];

    rhs.name = n["name"].as<std::string>();
    // ...
  }
};

Make sure that you have defined an appropriate copy-constructor for your EngineNode class:

class EngineNode {
public:
    EngineNode();
    EngineNode(const EngineNode &rhs); // Copy-constructor
    ~EngineNode();
// ...
};

That way, when your EngineNode is assigned in YamlConfig::read, it will make a valid copy if re-written like this:

EngineNode *YamlConfig::read(std::string path) {
    YAML::Node doc = YAML::LoadFile(path);
    EngineNode *node = new EngineNode(doc.as<EngineNode>());

    // ...

    return node;
}

Anyone calling this function should be aware that this allocates a new EngineNode object on the heap. This object will probably need to be deallocated at some point by calling delete on it. Alternatively, you could rework your API to use smart pointers:

std::shared_ptr<EngineNode> YamlConfig::read(std::string path) {
    YAML::Node doc = YAML::LoadFile(path);
    auto node = std::make_shared(doc.as<EngineNode>());

    // ...

    return node;
}

edited Mar 9, 2015 at 20:27

answered Mar 9, 2015 at 20:01

Austin Mullins

7,4673 gold badges35 silver badges48 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

blackwolf123333 Over a year ago

Shouldn't it be doc.as<EngineNode*>() ? In YamlConfig::read. Because otherwise the templates won't match.

Austin Mullins Over a year ago

No. The point was to rewrite decode so that it takes a reference to an EngineNode, not a pointer. This is because the as function allocates an EngineNode on the stack, not on the heap.

blackwolf123333 Over a year ago

Yes, that makes sense, but you still have struct convert<EngineNode*>, so yaml-cpp doesn't know what to do with as<EngineNode>.

Collectives™ on Stack Overflow

How to store a string from YAML::Node in a class using template decoding

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related