LightstreamerClient.h

#ifndef INCLUDED_Lightstreamer_LightstreamerClient
#define INCLUDED_Lightstreamer_LightstreamerClient
 
#include "../Lightstreamer.h"
#include "Lightstreamer/LoggerProvider.h"
#include "Lightstreamer/Subscription.h"
#include "Lightstreamer/ConnectionOptions.h"
#include "Lightstreamer/ConnectionDetails.h"
#include "Lightstreamer/LightstreamerError.h"
 
namespace Lightstreamer {
 
class LightstreamerClient {
  HaxeObject _client;
public:
  static const char* initialize(void (*unhandledExceptionCallback)(const char *exceptionInfo) = nullptr) {
    return Lightstreamer_initializeHaxeThread(unhandledExceptionCallback);
  }
  static void stop() {
    Lightstreamer_stopHaxeThreadIfRunning(true);
  }
  static std::string libName() {
    return LightstreamerClient_getLibName();
  }
  static std::string libVersion() {
    return LightstreamerClient_getLibVersion();
  }
  static void setLoggerProvider(LoggerProvider* provider) {
    LightstreamerClient_setLoggerProvider(provider);
  }
  static void addCookies(const std::string& uri, const std::vector<std::string>& cookies){
    LightstreamerClient_addCookies(&uri, &cookies);
  }
  static std::vector<std::string> getCookies(const std::string& uri) {
    return LightstreamerClient_getCookies(&uri);
  }
  static void setTrustManagerFactory(const std::string& caFile, const std::string& certificateFile, const std::string& privateKeyFile = "", const std::string& password = "", bool verifyCert = true) {
    LightstreamerClient_setTrustManagerFactory(&caFile, &certificateFile, &privateKeyFile, &password, verifyCert);
  }
  ConnectionOptions connectionOptions;
  ConnectionDetails connectionDetails;
 
  LightstreamerClient(const LightstreamerClient&) = delete;
  LightstreamerClient& operator=(const LightstreamerClient&) = delete;
 
  explicit LightstreamerClient(const std::string& serverAddress = "", const std::string& adapterSet = "") {
    _client = LightstreamerClient_new(&serverAddress, &adapterSet);
    connectionOptions.initDelegate(_client);
    connectionDetails.initDelegate(_client);
  }
 
  ~LightstreamerClient() {
    LightstreamerClient_disconnect(_client);
    Lightstreamer_releaseHaxeObject(_client);
  }
  void addListener(ClientListener* listener) {
    if (listener == nullptr)
      throw LightstreamerError("Argument cannot be null");
    LightstreamerClient_addListener(_client, listener);
  }
  void removeListener(ClientListener* listener) {
    if (listener == nullptr)
      throw LightstreamerError("Argument cannot be null");
    LightstreamerClient_removeListener(_client, listener);
  }
  std::vector<ClientListener*> getListeners() {
    return LightstreamerClient_getListeners(_client);
  }
  void connect() {
    LightstreamerClient_connect(_client);
  }
  void disconnect() {
    LightstreamerClient_disconnect(_client);
  }
  std::string getStatus() {
    return LightstreamerClient_getStatus(_client);
  }
  void subscribe(Subscription* subscription) {
    if (subscription == nullptr)
      throw LightstreamerError("Argument cannot be null");
    LightstreamerClient_subscribe(_client, subscription->_delegate);
  }
  void unsubscribe(Subscription* subscription) {
    if (subscription == nullptr)
      throw LightstreamerError("Argument cannot be null");
    LightstreamerClient_unsubscribe(_client, subscription->_delegate);
  }
  std::vector<Subscription*> getSubscriptions() {
    return LightstreamerClient_getSubscriptions(_client);
  }
  void sendMessage(const std::string& message, const std::string& sequence = "", int delayTimeout = -1, ClientMessageListener* listener = nullptr, bool enqueueWhileDisconnected = false) {
    LightstreamerClient_sendMessage(_client, &message, &sequence, delayTimeout, listener, enqueueWhileDisconnected);
  }
};
 
} // namespace Lightstreamer
 
#endif // INCLUDED_Lightstreamer_LightstreamerClient