pub unsafe trait Inherits<Base: GodotClass>: GodotClass {
const IS_SAME_CLASS: bool = false;
}Expand description
Non-strict inheritance relationship in the Godot class hierarchy.
Derived: Inherits<Base> means that either Derived is a subclass of Base, or the class Base itself (hence “non-strict”).
This trait is automatically implemented for all Godot engine classes and user-defined classes that derive GodotClass.
It has GodotClass as a supertrait, allowing your code to have bounds solely on Derived: Inherits<Base> rather than
Derived: Inherits<Base> + GodotClass.
Inheritance is transitive across indirect base classes: Node3D implements Inherits<Node> and Inherits<Object>.
The trait is also reflexive: T always implements Inherits<T>.
§Usage
The primary use case for this trait is polymorphism: you write a function that accepts anything that derives from a certain class (including the class itself):
fn print_node<T>(node: Gd<T>)
where
T: Inherits<Node>,
{
let up = node.upcast(); // type Gd<Node> inferred
println!("Node #{} with name {}", up.instance_id(), up.get_name());
up.free();
}
// Call with different types
print_node(Node::new_alloc()); // works on T=Node as well
print_node(Node2D::new_alloc()); // or derived classes
print_node(Node3D::new_alloc());A variation of the above pattern works without Inherits or generics, if you move the upcast() into the call site:
fn print_node(node: Gd<Node>) { /* ... */ }
// Call with different types
print_node(Node::new_alloc()); // no upcast needed
print_node(Node2D::new_alloc().upcast());
print_node(Node3D::new_alloc().upcast());§Safety
This trait must only be implemented for subclasses of Base.
Importantly, this means it is always safe to upcast a value of type Gd<Self> to Gd<Base>.
Provided Associated Constants§
Sourceconst IS_SAME_CLASS: bool = false
const IS_SAME_CLASS: bool = false
True iff Self == Base.
Exists because something like C++’s std::is_same is notoriously difficult
in stable Rust, due to lack of specialization.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.