OpenFinAdapter.h

#pragma once
 
#include <future>
#include <string>
#include <map>
 
// common.h
#define OPENFIN_ADAPTER_API __declspec(dllimport) 
 
namespace OpenFinAdapterApi {
    using namespace std;
    // EndpointId.h
    struct EndpointId
    {
    public:
        std::string uuid;
        std::string name;
        std::string channelName;
        std::string channelId;
        std::string endpointId;
    };
 
    // MessageChannelClient.h
    class OPENFIN_ADAPTER_API MessageChannelClient
    {
    public:
        void registerTopic(const string& topic, const function<shared_ptr<string>(shared_ptr<string>, EndpointId)>& listener);
 
        void unregisterTopic(const string& topic);
    };
 
    // ChannelClient.h
    class OPENFIN_ADAPTER_API ChannelClient : public MessageChannelClient
    {
    public:
        shared_future<void> connectAsync(bool wait = true);
 
        shared_future<void> disconnectAsync() const;
 
        shared_future<shared_ptr<string>> dispatchAsync(const string& topic) const;
 
        shared_future<shared_ptr<string>> dispatchAsync(const string& topic, const string& payloadJson) const;
 
        void subscribeDisconnected(const function<void()>& listener);
 
        void unsubscribeDisconnected(const function<void()>& listener);
    };
 
    // ChannelProvider.h  
    class OPENFIN_ADAPTER_API ChannelProvider : public MessageChannelClient
    {
    public:
        shared_future<void> openAsync();
 
        void subscribeClientConnected(const function<void(const EndpointId&)>& listener);
 
        void unsubscribeClientConnected(const function<void(const EndpointId&)>& listener);
 
        void subscribeClientDisconnected(const function<void(const EndpointId&)>& listener);
 
        void unsubscribeClientDisconnected(const function<void(const EndpointId&)>& listener);
 
        shared_future<shared_ptr<string>> dispatchAsync(const EndpointId& targetChannel, const string& topic) const;
 
        shared_future<shared_ptr<string>> dispatchAsync(const EndpointId& targetChannel, const string& topic, const string& payloadJson) const;
 
        shared_future<shared_ptr<string>> broadcastAsync(const string& topic, const string& payloadJson) const;
 
        shared_future<shared_ptr<string>> broadcastAsync(const string& topic) const;
    };
 
    // Channels.h
    class OPENFIN_ADAPTER_API Channels
    {
    public:
        shared_ptr<ChannelClient> createClient(const string& channelName);
 
        shared_ptr<ChannelProvider> createProvider(const string& channelName);
    };
 
    // OpenFinApiException.h
    class OPENFIN_ADAPTER_API OpenFinApiException : public std::exception
    {
    public:
        OpenFinApiException(const std::string& message);
 
        const char* what() const noexcept override;
    };
 
    // RvmOptions.h
    class OPENFIN_ADAPTER_API RvmOptions
    {
 
    public:
        struct RvmCacheKey {
            string productName;
            string productVersion;
            string companyName;
            string runtimeVersion;
        };
 
        bool noUi;
        bool disableAutoUpdates;
        bool doNotLaunch;
        string installDirectory;
        string workingDirectory;
        RvmCacheKey cacheKey;
 
        RvmOptions(bool no_ui,
            bool disableAutoUpdates,
            bool doNotLaunch,
            const string& installDirectory,
            const string& workingDirectory,
            const string& productName,
            const string& productVersion,
            const string& companyName,
            const string& runtimeVersion);
    };
 
    // RuntimeOptions.h
    class OPENFIN_ADAPTER_API RuntimeOptions
    {
    public:
        enum PortDiscoveryMode {
            None,
            WindowClass
        };
 
        enum class RuntimeConnectOptions : uint16_t {
            None = 0x0000,
            NonPersistent = 0x0001,
        };
 
        string uuid;
 
        string license_key;
 
        string version;
 
        string  host;
 
        int32_t port;
 
        PortDiscoveryMode portDiscoveryMode;
 
        string arguments;
 
        RvmOptions* rvmOptions;
 
        string securityRealm;
 
        RuntimeConnectOptions runtimeConnectOptions;
 
        RuntimeOptions(const string& uuid,
            const string& licenseKey,
            const string& version,
            const string& host,
            int32_t port,
            PortDiscoveryMode portDiscoveryMode,
            const string& arguments,
            const RvmOptions& rvmOptions,
            const string& securityRealm,
            const RuntimeConnectOptions runtimeConnectOptions = RuntimeConnectOptions::None);
 
        RuntimeOptions(
            const string& uuid,
            const string& licenseKey,
            const string& version
        );
 
    };
 
    // DesktopSystem.h
    class OPENFIN_ADAPTER_API DesktopSystem {
    public:
        shared_future<shared_ptr<string>> launchManifest(const string& manifestUrl, const shared_ptr<RvmOptions>& rvmOptions = nullptr) const;
    };
 
    // Runtime.h
    class OPENFIN_ADAPTER_API Runtime
    {
    public:
        bool isConnected() const;
 
        string getRuntimeId();
 
        RuntimeOptions getRuntimeOptions();
 
        future<void> connectAsync();
 
        future<void> disconnectAsync();
 
        shared_ptr<Channels> getChannels();
 
        shared_ptr<DesktopSystem> getDesktopSystem();
 
        void subscribeDisconnected(const function<void()>& listener);
 
        void unsubscribeDisconnected(const function<void()>& listener);
    };
 
    // RuntimeFactory.h
    class OPENFIN_ADAPTER_API RuntimeFactory
    {
    private:
        map<string, shared_ptr<Runtime>> runtimes;
 
    public:
        shared_ptr<Runtime> getRuntimeInstance(const RuntimeOptions& runtimeOptions);
    };
}