IEventsAdapter.h#

// Copyright (c) 2024-2025, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "../Interface.h"
#include "../IObject.h"
#include "../RString.h"
#include "../cpp/Span.h"
#include "IEvents.h"

#include "../../omni/Expected.h"
#include "../../omni/core/Result.h"

#define carb_events_IEventsAdapter_latest CARB_HEXVERSION(1, 1)
#ifndef carb_events_IEventsAdapter
#    define carb_events_IEventsAdapter carb_events_IEventsAdapter_latest
#endif

namespace carb
{
namespace eventdispatcher
{
class IMessageQueue;
}

namespace events
{

enum class AdapterType
{
    eDispatch,
    ePushPump,
    eFull,
#if CARB_VERSION_ATLEAST(carb_events_IEventsAdapter, 1, 1)
    eFullAlias,
#endif

    // Must be last. Also this value can vary by version, so it is not considered ABI safe and should therefore not be
    // passed back from the API.
    eCount
};

struct MappingEntry
{
    EventType type;

    RString dispatchName;

    RString pushName;

    constexpr MappingEntry(EventType type, RString dispatchName, RString pushName = RString()) noexcept
        : type(type), dispatchName(dispatchName), pushName(pushName)
    {
    }
};

struct AdapterDesc
{
    uint32_t sizeOf{ uint32_t(sizeof(AdapterDesc)) };

    AdapterType type;

    const char* name;

    cpp::span<MappingEntry> mappings;

    eventdispatcher::IMessageQueue* messageQueue;

    constexpr AdapterDesc(AdapterType type,
                          const char* name,
                          cpp::span<MappingEntry> mappings,
                          eventdispatcher::IMessageQueue* messageQueue = nullptr) noexcept
        : type(type), name(name), mappings(mappings), messageQueue(messageQueue)
    {
    }
};

class IEventsAdapter
{
public:
    // 1.0 - Initial release
    CARB_PLUGIN_INTERFACE_EX("carb::events::IEventsAdapter", carb_events_IEventsAdapter_latest, carb_events_IEventsAdapter);

    virtual IEventStream* internalCreateAdapter(const AdapterDesc& desc, omni::core::Result& result) noexcept = 0;

    omni::expected<IEventStreamPtr, omni::core::Result> createAdapter(const AdapterDesc& desc) noexcept
    {
        omni::core::Result result;
        if (auto p = internalCreateAdapter(desc, result))
        {
            return omni::expected<IEventStreamPtr, omni::core::Result>(carb::stealObject(p));
        }
        return omni::unexpected<omni::core::Result>(result);
    }
};

} // namespace events
} // namespace carb