rtl::CxxMirror cxx_mirror({/* register all types here */});

// Without reflection
Person p("John", 42);
p.setAge(43);
std::cout << p.getName();

// With reflection
auto classPerson = cxx_mirror.getRecord("Person");      // Get the class as 'rtl::Record'.

auto [err, robj] = classPerson->create<alloc::Stack>("John", 42);   // Get the instance (robj) as 'rtl::RObject'.

auto setAge = classPerson->getMethod("setAge");     // Get the method as 'rtl::Method'.

setAge->bind(robj).call(43);    // Bind the rtl::RObject with rtl::Method and make the call with arguments.

auto getName = classPerson->getMethod("getName");

auto [err2, ret] = getName->bind(robj).call();      // Get return value as rtl::RObject.

std::cout << ret.view<std::string>()->get();    // access return value as std::string.

class Person {
    int age;
    std::string name;
	
public:
    Person();
    Person(const std::string, int);

    void setAge(int);
    void setName(const std::string, const std::string&);

    int getAge() const;
    std::string getName() const;
};

#include "RTLibInterface.h" // Single header: provides all registration & access interfaces.
#include "Person.h"         // User-defined types to be reflected.

using namespace rtl::access;
using namespace rtl::builder;

const CxxMirror& MyReflection()
{
    static const CxxMirror cxxReflection({
        // Register member functions
        Reflect().record<Person>("Person").method("setAge").build(&Person::setAge),
        Reflect().record<Person>("Person").method("getAge").build(&Person::getAge),
        Reflect().record<Person>("Person").method("setName").build(&Person::setName),
        Reflect().record<Person>("Person").method("getName").build(&Person::getName),

        // Registering any method (including but not limited to constructors) will  
        // automatically reflect the copy-constructor & destructor (if accessible).
        Reflect().record<Person>("Person").constructor().build(),  // Default constructor
        Reflect().record<Person>("Person").constructor<std::string, int>().build() // Parameterized constructor
    });

    return cxxReflection;
}

Reflect().nameSpace("..")   // Optional: specify namespace if the type is enclosed in one.
         .record<..>("..")  // Register class/struct type (template parameter) and its name (string).
         .method("..")      // Register function by name.
         .build(*);         // Pass function pointer.

Reflect().nameSpace("..")
         .record<..>("..")
         .constructor<..>() // Register constructor with template parameters as signature.
         .build();          // No function pointer needed for constructors.

#include "RTLibInterface.h" // Reflection access interface.

// True runtime reflection – no compile-time access to types.
// Works without even knowing what it's reflecting.
extern const rtl::CxxMirror& MyReflection();

using namespace rtl::access;

int main()
{
//  Lazily-initialized reflection system (singleton-style, pay-only-when-you-use).
//  Get 'class Person' — returns a 'Record' representing the reflected class.
    std::optional<Record> classPerson = MyReflection().getClass("Person");

/*  Create an instance of 'class Person' using the default constructor.
    Choose between heap or stack allocation with 'alloc::Heap' or 'alloc::Stack'.
    Returns: std::pair<error, RObject>. RObject is empty if:
       * error != error::None (creation or reflection call failure).
       * OR the reflected function is 'void'.
    'RObject' wraps a type-erased object, which can be:
        * An instance created via reflection (constructor).
        * OR a value returned from any reflection-based call.
     Internally:
        * Uses std::unique_ptr for heap-allocated reflection-created instances.
        * Return values are unmanaged.
        * Copy/move behave as value-type copies:
            - Heap: follows semantics of unique_ptr.
            - Stack: creates distinct object copies.
*/  auto [err0, person0] = classPerson->create<alloc::Heap>();

//  Ensure object was created successfully.
    if (err0 != error::None)
        return -1;

//  Create instance via parameterized constructor.
    auto [err1, person1] = classPerson->create<alloc::Stack>(std::string("John Doe"), int(42));

//  Fetch a reflected method — returns optional 'Method'.
    std::optional<Method> setAge = classPerson->getMethod("setAge");
    if(!setAge)
        return -1;

//  Call method: returns [error code, return value].
    auto [err2, ret2] = setAge->bind(person0).call(42);

//  Alternative syntax (without bind, slightly slower).
    auto [err3, ret3] = (*setAge)(person1)(42);

//  Fetch and invoke another reflected method.
    std::optional<Method> setName = classPerson->getMethod("setName");
    const char* name = "Todd";  // will get converted to std::string due to strict-binding.
    std::string surname = "Packer";
//  use bind to specify strict-argument types explicitly. (enables Perfect-Forwarding.)
    auto [err4, ret4] = setName->bind<string, const string&>(personObj).call(name, surname);

//  Fetch method returning a value.
    std::optional<Method> getName = classPerson->getMethod("getName");

//  Call and retrieve return value.
    auto [err5, retName] = getName->bind(personObj).call();

    if (err5 == error::None && retName.canViewAs<std::string>())
    {
        const std::string& nameStr = retName.view<std::string>()->get();
        std::cout << nameStr << std::endl;
    }
    return 0; // Heap/Stack instances cleaned up via scope-based lifetime.
}