TransportConfig.hpp

#ifndef _DITTO_TRANSPORT_CONFIG_
#define _DITTO_TRANSPORT_CONFIG_
 
#include <chrono>
#include <set>
#include <string>
 
namespace ditto {
 
class TcpListenConfig {
public:
  bool enabled = false;
 
  std::string interface_ip = "0.0.0.0";
 
  uint16_t port = 4040;
 
  bool operator==(const TcpListenConfig &other) const {
    return (enabled == other.enabled && interface_ip == other.interface_ip &&
            port == other.port);
  }
  bool operator!=(const TcpListenConfig &other) const {
    return !operator==(other);
  }
};
 
class HttpListenConfig {
public:
  bool enabled = false;
 
  std::string interface_ip = "0.0.0.0";
 
  uint16_t port = 8080;
 
  bool websocket_sync = false;
 
  std::string static_content_path;
 
  std::string tls_key_path;
 
  std::string tls_certificate_path;
 
  bool operator==(const HttpListenConfig &other) const {
    return (enabled == other.enabled && interface_ip == other.interface_ip &&
            port == other.port && websocket_sync == other.websocket_sync &&
            static_content_path == other.static_content_path &&
            tls_key_path == other.tls_key_path &&
            tls_certificate_path == other.tls_certificate_path);
  }
  bool operator!=(const HttpListenConfig &other) const {
    return !operator==(other);
  }
};
 
class Listen {
public:
  TcpListenConfig tcp;
  HttpListenConfig http;
};
 
class BluetoothLeConfig {
public:
  bool enabled = false;
 
  bool operator==(const BluetoothLeConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const BluetoothLeConfig &other) const {
    return !operator==(other);
  }
};
 
class LanConfig {
public:
  bool enabled = false;
  // TODO: Rename these to `mdns_enabled` and `multicast_enabled`
  bool mdns_enabled = true;
  bool multicast_enabled = true;
 
  bool operator==(const LanConfig &other) const {
    return enabled == other.enabled && mdns_enabled == other.mdns_enabled &&
           multicast_enabled == other.multicast_enabled;
  }
  bool operator!=(const LanConfig &other) const { return !operator==(other); }
};
 
class AwdlConfig {
public:
  bool enabled = false;
 
  bool operator==(const AwdlConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const AwdlConfig &other) const { return !operator==(other); }
};
 
class WiFiAwareConfig {
public:
  bool enabled = false;
 
  bool operator==(const WiFiAwareConfig &other) const {
    return enabled == other.enabled;
  }
  bool operator!=(const WiFiAwareConfig &other) const {
    return !operator==(other);
  }
};
 
class PeerToPeer {
public:
  BluetoothLeConfig bluetooth_le;
 
  LanConfig lan;
 
  AwdlConfig awdl;
 
  WiFiAwareConfig wifi_aware;
};
 
class Connect {
public:
  std::set<std::string> tcp_servers;
 
  std::set<std::string> websocket_urls;
 
  std::chrono::duration<uint32_t, std::milli> retry_interval{5000};
};
 
const uint32_t NO_PREFERRED_ROUTE_HINT = 0;
 
class Global {
public:
  uint32_t sync_group = 0;
 
  uint32_t routing_hint = NO_PREFERRED_ROUTE_HINT;
};
 
class TransportConfig {
public:
  PeerToPeer peer_to_peer;
 
  Connect connect;
 
  Listen listen;
 
  Global global;
 
  void enable_all_peer_to_peer() {
    peer_to_peer.bluetooth_le.enabled = true;
    peer_to_peer.lan.enabled = true;
    peer_to_peer.awdl.enabled = true;
    peer_to_peer.wifi_aware.enabled = true;
  }
};
} // namespace ditto
 
#endif // _DITTO_TRANSPORT_CONFIG_