Safer implementation of user data attached to node

[rh101]

At the moment there are methods in Node that support attaching custom data to a node, being:

Node::setUserData(void* userData);
const void* Node::getUserData() const();

The problem with this is one of memory management. If a pointer to an object is set as the custom user data, then there is no way to know if that object needs to be freed, since there is no indicator of object ownership.

What I propose is that new methods are added, which allow ownership and object lifetime to be clearly defined. The existing void* implementations should remain in case they are being used in existing projects.

For example, we can add objects that are of type ax::Ref*, so that they can be reference counted, and if that object is no longer required, then it automatically frees itself. Something along the lines of:

Node::setUserData(ax::Ref* userData)
{
    if (userData == _refCountedUserData)
        return;

    AX_SAFE_RELEASE(_refCountedUserData);

    userData->retain(); 
    _refCountedUserData = userData;
}

const ax::Ref* Node::getUserData() const() { return _refCountedUserData; }

Node::~Node()
{
    AX_SAFE_RELEASE(_refCountedUserData);
}

Another option would be using smart pointers:

// Inherit from this interface for data to be stored in the node
class IUserData
{
public:
    virtual ~IUserData() = 0;
}
IUserData::~IUserData() = default; //required since the destructor is pure virtual

Node::setUserData(std::shared_ptr<IUserData> userData)
{
    if (userData == _smartUserData)
        return;

    _smartUserData= userData;
}

const IUserData* Node::getUserData() const() { return  _smartUserData.get(); }

Node::~Node()
{
     _smartUserData = nullptr; // Not actually required, but just for this example
}

Would any of the above suggestions be useful?

[iAndyHD3]

doesn't it already exist?

ax::Node::setUserObject

Similar to UserData, but instead of holding a void* it holds an object. The UserObject will be retained once in this method, and the previous UserObject (if existed) will be released. The UserObject will be released in Node's destructor.

[rh101]

!!!! How have I never noticed that?? /facepalm

Thank you for that.

[rh101]

Closing this thanks to @iAndyHD3 pointing out what I completely missed.