Presence.hpp

#ifndef DITTO_PRESENCE_MANAGER_H
#define DITTO_PRESENCE_MANAGER_H
 
#include "Arc.hpp"
#include "ConnectionRequest.hpp"
#include "DittoHandleWrapper.hpp"
#include "PresenceGraph.hpp"
#include "any.hpp"
 
#include <cstddef>
#include <memory>
#include <string>
 
using dittoffi_connection_request_t = struct dittoffi_connection_request;
 
namespace ditto {
 
struct OnConnectingWrapper;
 
class DittoHandleWrapper;

using PresenceCallback = std::function<void(PresenceGraph)>;
using PresenceObserverInternal = std::weak_ptr<PresenceCallback>;
using PresenceObserver = std::shared_ptr<PresenceCallback>;

class Presence {
  friend class Ditto;
 
public:
  PresenceObserver observe(PresenceCallback presence_cb);

  DITTO_DEPRECATED PresenceGraph exec();

  PresenceGraph graph();

  nlohmann::json peer_metadata() const;

  void set_peer_metadata(nlohmann::json const &peer_metadata);

  std::string peer_metadata_json_string() const;

  void set_peer_metadata_json_string(std::string json_string);

  void set_connection_request_handler(
      ConnectionRequestHandler connection_request_handler);

  void set_connection_request_handler(std::nullptr_t);
 
private:
  explicit Presence(std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper);
  friend struct PresenceInternal;

  void on_presence(PresenceGraph presence_graph);
 
  std::shared_ptr<DittoHandleWrapper> ditto_handle_wrapper;
  std::vector<PresenceObserverInternal> observers;
  bool registered;
 
  static void
  on_connecting(Arc<ConnectionRequestHandler> const &handler,
                dittoffi_connection_request_t *ffi_connection_request);
};
} // namespace ditto
#endif