DittoConfig.hpp

#ifndef DITTO_DITTO_CONFIG_H
#define DITTO_DITTO_CONFIG_H
 
#include "json.hpp"
 
#include <memory>
#include <string>
 
#ifdef __ANDROID__
#include <jni.h>
#endif /* __ANDROID__ */
 
namespace ditto {

struct DittoConfig {

  class Connect {
  public:
    enum class Type { server, small_peers_only };
 
    virtual ~Connect() = default;
    virtual Type get_type() const = 0;

    static std::shared_ptr<Connect> server(std::string url);

    static std::shared_ptr<Connect>
    small_peers_only(std::string private_key = "");
  };

  class ServerConnect : public Connect {
  private:
    std::string url;
 
  public:
    explicit ServerConnect(std::string url);
 
    ServerConnect(const ServerConnect &other) = default;
    ServerConnect(ServerConnect &&other) = default;
    ServerConnect &operator=(const ServerConnect &other) = default;
    ServerConnect &operator=(ServerConnect &&other) = default;
    ~ServerConnect() override = default;
 
    Type get_type() const override;
    const std::string &get_url() const;
  };

  class SmallPeersOnlyConnect : public Connect {
  private:
    std::string private_key;
 
  public:
    explicit SmallPeersOnlyConnect(std::string private_key = "");
 
    SmallPeersOnlyConnect(const SmallPeersOnlyConnect &other) = default;
    SmallPeersOnlyConnect(SmallPeersOnlyConnect &&other) = default;
    SmallPeersOnlyConnect &
    operator=(const SmallPeersOnlyConnect &other) = default;
    SmallPeersOnlyConnect &operator=(SmallPeersOnlyConnect &&other) = default;
    ~SmallPeersOnlyConnect() override = default;
 
    Type get_type() const override;
    const std::string &get_private_key() const;
  };

  std::string database_id;

  std::shared_ptr<Connect> connect;

  struct Experimental {
    std::string passphrase;

    Experimental &set_passphrase(std::string pass) noexcept;
  };

  Experimental experimental;
 
#ifdef __ANDROID__
  void *android_context = nullptr;
#endif

  std::string persistence_directory;

  DittoConfig() = default;
 
  DittoConfig(const DittoConfig &other) = default;
  DittoConfig(DittoConfig &&other) = default;
  DittoConfig &operator=(const DittoConfig &other) = default;
  DittoConfig &operator=(DittoConfig &&other) = default;
  ~DittoConfig() = default;

  static DittoConfig default_config();
 
#ifdef __ANDROID__
  DittoConfig &set_android_context(void *android_context) noexcept;
#endif

  DittoConfig &set_database_id(std::string database_id) noexcept;

  DittoConfig &
  set_persistence_directory(std::string persistence_directory) noexcept;

  DittoConfig &set_connect(std::shared_ptr<Connect> connect) noexcept;

  DittoConfig &set_server_connect(std::string url) noexcept;

  DittoConfig &
  set_small_peers_only_connect(std::string private_key = "") noexcept;

  DittoConfig &set_experimental(Experimental exp) noexcept;

  static std::string default_database_id() noexcept;
};
 
// JSON serialization for DittoConfig
void to_json(nlohmann::json &j, const DittoConfig &c);
void from_json(const nlohmann::json &j, DittoConfig &c);
 
} // namespace ditto
 
#endif