session.topics.addMissingTopicHandler('topic_branch', {
    // Implement handling code
    onMissingTopic: (notification) => {
        // a missing topic notification has been received
    },
    onClose: (path) => {
        // the handler is closed
    },
    onError: (path, error) => {
        // an error occured
    },
    onRegister: (path, deregister) => {
        // the missing topic notification handler has been registered
    }
});

string topicPath = "Example/Some Topic";

WriteLine($"Adding missing topic handler for topic '{topicPath}'.");

var registration = 
    await controlSession.TopicControl.AddMissingTopicHandlerAsync(
            topicPath, 
            new MissingTopicNotificationStream(controlSession));


...


/// <summary>
/// Basic implementation of the stream that will be called when a session subscribes using
/// a topic selector that matches no topics.
/// </summary>
private sealed class MissingTopicNotificationStream : IMissingTopicNotificationStream
{
    private ISession session;

    public MissingTopicNotificationStream(ISession session) => this.session = session;

    public void OnClose() => WriteLine("Handler is removed.");

    public void OnError(ErrorReason errorReason) 
                => WriteLine($"An error has occured : {errorReason}.");

    public void OnMissingTopic(IMissingTopicNotification notification)
    {
        WriteLine($"Topic '{notification.TopicPath}' does not exist.");

        session.TopicControl.AddTopic(
                notification.TopicPath, 
                session.TopicControl.NewSpecification(TopicType.STRING), 
                new TopicControlAddCallback(notification));
    }
}

final Session session = Diffusion.sessions().open("ws://localhost:8080");
final TopicControl topicControl = session.feature(TopicControl.class);

topicControl.addMissingTopicHandler("my/topic/path", new MyNotificationStream());

/**
 * Copyright © 2021 - 2023 DiffusionData Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <stdlib.h>
#ifndef WIN32
        #include <unistd.h>
#else
        #define sleep(x) Sleep(1000 * x)
#endif

#include "diffusion.h"


static int on_missing_topic(
        SESSION_T *session,
        const SVC_MISSING_TOPIC_REQUEST_T *request,
        void *context)
{
        // handle missing topic notification
        return HANDLER_SUCCESS;
}


int main(int argc, char **argv)
{
        const char *url = "ws://localhost:8080";
        const char *principal = "control";
        const char *password = "password";
        const char *topic_path = "my/topic/path";

        CREDENTIALS_T *credentials = credentials_create_password(password);

        SESSION_T *session;
        DIFFUSION_ERROR_T error = { 0 };

        // Create a session, synchronously
        session = session_create(url, principal, credentials, NULL, NULL, &error);
        if(session == NULL) {
                printf("Failed to create session: %s\n", error.message);
                free(error.message);
                credentials_free(credentials);
                return EXIT_FAILURE;
        }

        // register missing topic handler
        MISSING_TOPIC_PARAMS_T params = {
                .on_missing_topic = on_missing_topic,
                .topic_path = topic_path,
                .context = NULL
        };
        missing_topic_register_handler(session, params);

        // Sleep for a while
        sleep(5);

        // Close the session, and release resources and memory
        session_close(session, NULL);
        session_free(session);

        credentials_free(credentials);

        return EXIT_SUCCESS;
}

class MissingTopicNotify : PTDiffusionMissingTopicHandler {

    func diffusionTopicTreeRegistration(_ registration: PTDiffusionTopicTreeRegistration,
                                        hadMissingTopicNotification notification: PTDiffusionMissingTopicNotification) {
        // handle missing topic notification
    }


    func diffusionTopicTreeRegistrationDidClose(_ registration: PTDiffusionTopicTreeRegistration) {
        // registration has closed
    }


    func diffusionTopicTreeRegistration(_ registration: PTDiffusionTopicTreeRegistration,
                                        didFailWithError error: Error) {
        // registration failed with error
    }


    func handler_register(session: PTDiffusionSession) {
        session.topicControl.add(self, forTopicPath: "topic_branch") { (registration, error) in
            if (error != nil) {
                print("An error has occurred: %@", error!.localizedDescription)
                return
            }

            // missing topic handler has been registered
        }
    }
}