An object is a named, hierarchical component of the runtime engine. Everything in a loaded tree is an LObject.

LObject           base for parent/child ownership rules
├── LLayer        object described by attributes and other layers
└── LAttribute    object storing a data value or link

The loader (see LLoader) constructs the tree from a set of .lyr files. Hand construction of objects is usually not necessary.

Parents and children

Objects own their children. To add a child to an object, pass it to add_child() as a std::unique_ptr instance. add_child() uses a move operation making the object responsible for the child's lifetime.

auto parent = std::make_unique<LObject>();
auto child  = std::make_unique<LObject>();

LObject* child_ptr = child.get();
parent->add_child(std::move(child));  // `parent` now owns `child`;
                                      // the `child` object becomes null

After add_child() establishes the relationship, the child knows who its parent is; calling parent() from the child acquires it. parent() returns a raw pointer to the parent object for observation. Do not attempt to manage it since its lifetime is already handled by std::unique_ptr.

LObject* parent_ptr = child_ptr->parent();  // Returns observational,
                                            // raw pointer to `parent`

Creating objects with lMake factory

lMake<T>() creates the child and parents it in one step. Here's an example creating LLayer and LAttribute objects:

LLayer* button   = lMake<LLayer>(engine.root(), "Button");
            // Create `Button` layer and parent it to the engine's root

LAttribute* fill = lMake<LAttribute>(button, "Fill");
            // Create `Fill` attribute and parent it to `Button`

Why not pass the parent to the constructor?

An object cannot parent itself during construction. add_child() needs the std::unique_ptr that owns the object, which doesn't exist while constructing since std::make_unique hasn't returned. So the order is to construct, then parent.

If you're coming from Qt, then you're used to QObject(QObject* parent). Layers objects are owned using unique_ptr instead of raw pointers, so parenting has to work differently. lMake<T>() should help make the process more familiar.