Rocket C++ Signal/Slots Library

Rocket provides two primary ways to prevent dangling pointers when an observer is destroyed:

1. rocket::scoped_connection: A RAII object that automatically disconnects the slot when it goes out of scope. Use this if you want to manage the connection lifetime manually or within a specific block.
2. rocket::trackable: If an observer class inherits from rocket::trackable, the signal will automatically detect when the object is destroyed and disconnect any associated slots. This is the most automated way to handle lifetime tracking.

Note: For trackable to work, the class must inherit from rocket::trackable.

// Using scoped_connection
{
    std::unique_ptr<ILogger> logger = std::make_unique<ConsoleLogger>();
    rocket::scoped_connection connection = app->onSuccess
        .connect(logger.get(), &ILogger::logMessage);
    app->run();
}
// logger is destroyed, connection is destroyed, slot is disconnected.

// Using rocket::trackable
struct ILogger : rocket::trackable {
    virtual void logMessage(const std::string& message) = 0;
};
// When ILogger instance is destroyed, the signal automatically disconnects.

You can connect member functions of a class instance to a signal. This is typically done by passing the instance pointer to the connect method.

To ensure connections are cleaned up when the observer is destroyed, store the returned connection object in a rocket::scoped_connection_container or a rocket::scoped_connection.

class Subject {
public:
    void setName(const std::string& newName) {
        if (name != newName) {
            name = newName;
            nameChanged(newName);
        }
    }
    rocket::signal<void(std::string)> nameChanged;
private:
    std::string name;
};

class Observer {
public:
    Observer(Subject& subject) {
        // Store connection in a container to break it when Observer is destroyed
        connections += {
            subject.nameChanged.connect<&Observer::onNameChanged>(this)
        };
    }

    void onNameChanged(const std::string& name) {
        std::cout << "Subject received new name: " << name << std::endl;
    }

private:
    rocket::scoped_connection_container connections;
};

You can use the rocket::queued_connection flag when calling connect to create a message queue between threads. Instead of executing the slot immediately in the thread that invokes the signal, rocket schedules the execution to occur in the thread where the connect call was originally made.

To process these queued calls, you must periodically call rocket::dispatch_queued_calls() in the target thread (e.g., your main render loop). This ensures that the slots are executed within the context of that thread, allowing you to modify thread-local data without explicit locking.

// 1. Connect using the queued_connection flag
modelLoaderThread.modelLoaded.connect<&RenderThread::onModelLoaded>(this, rocket::queued_connection);

// 2. In your target thread's loop, dispatch the calls
void RenderThread::render() {
    rocket::dispatch_queued_calls(); // Executes the queued slots on this thread
    // ... rest of render logic
}

// 3. The slot is now thread-safe relative to the RenderThread's data
void RenderThread::onModelLoaded(ModelFilePtr const& modelFile) {
    renderables.push_back(new ModelRenderer(modelFile));
}

When a signal's signature includes a return type (e.g., rocket::signal<int(int)>), the signal can collect values from its connected slots.

• Default Behavior: The signal returns an std::optional<T> containing the result of the slots.
• Custom Collectors: You can specify a value collector at declaration time (e.g., rocket::range<T>) to change how results are aggregated.
• Invocation-time Overrides: You can use .invoke<Collector>(args...) to specify a different collection policy for a single call.

Common collectors include rocket::range<T>, rocket::first<T>, and rocket::last<T>.

// Default: returns optional<int>
rocket::signal<int(int)> signal;
signal.connect(std::sqrtf);
int result = *signal(16);

// Using rocket::range to get all results
rocket::signal<float(float), rocket::range<float>> signal;
signal.connect(std::sinf);
signal.connect(std::cosf);
for (auto result : signal(3.14159)) { /* ... */ }

// Overriding at invocation time
float first = signal.invoke<rocket::first<float>>(3.14159);
float last = signal.invoke<rocket::last<float>>(3.14159);