nearby/sharing/linux/daemon/nearby_sharing_server.h

/*
 * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
 */

#ifndef __sdbuscpp__sharing_linux_daemon_nearby_sharing_server_h__adaptor__H__
#define __sdbuscpp__sharing_linux_daemon_nearby_sharing_server_h__adaptor__H__

#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>

namespace com {
namespace google {
namespace nearby {

class sharing_adaptor {
 public:
  static constexpr const char* INTERFACE_NAME = "com.google.nearby.sharing";

 protected:
  sharing_adaptor(sdbus::IObject& object) : m_object(object) {}

  sharing_adaptor(const sharing_adaptor&) = delete;
  sharing_adaptor& operator=(const sharing_adaptor&) = delete;
  sharing_adaptor(sharing_adaptor&&) = delete;
  sharing_adaptor& operator=(sharing_adaptor&&) = delete;

  ~sharing_adaptor() = default;

  void registerAdaptor() {
    m_object
        .addVTable(
            sdbus::registerMethod("StartReceive")
                .withOutputParamNames("ok", "message")
                .implementedAs([this]() { return this->StartReceive(); }),
            sdbus::registerMethod("StopReceive")
                .withOutputParamNames("ok", "message")
                .implementedAs([this]() { return this->StopReceive(); }),
            sdbus::registerMethod("StartDiscovery")
                .withOutputParamNames("ok", "message")
                .implementedAs([this]() { return this->StartDiscovery(); }),
            sdbus::registerMethod("StopDiscovery")
                .withOutputParamNames("ok", "message")
                .implementedAs([this]() { return this->StopDiscovery(); }),
            sdbus::registerMethod("SendFile")
                .withInputParamNames("share_target_id", "path")
                .withOutputParamNames("ok", "message")
                .implementedAs([this](const int64_t& share_target_id,
                                      const std::string& path) {
                  return this->SendFile(share_target_id, path);
                }),
            sdbus::registerMethod("Accept")
                .withInputParamNames("share_target_id")
                .withOutputParamNames("ok", "message")
                .implementedAs([this](const int64_t& share_target_id) {
                  return this->Accept(share_target_id);
                }),
            sdbus::registerMethod("Reject")
                .withInputParamNames("share_target_id")
                .withOutputParamNames("ok", "message")
                .implementedAs([this](const int64_t& share_target_id) {
                  return this->Reject(share_target_id);
                }),
            sdbus::registerMethod("Cancel")
                .withInputParamNames("share_target_id")
                .withOutputParamNames("ok", "message")
                .implementedAs([this](const int64_t& share_target_id) {
                  return this->Cancel(share_target_id);
                }),
            sdbus::registerMethod("Shutdown")
                .withOutputParamNames("ok", "message")
                .implementedAs([this]() { return this->Shutdown(); }),
            sdbus::registerSignal("TargetDiscovered")
                .withParameters<std::map<std::string, sdbus::Variant>>(
                    "share_target"),
            sdbus::registerSignal("TargetUpdated")
                .withParameters<std::map<std::string, sdbus::Variant>>(
                    "share_target"),
            sdbus::registerSignal("TargetLost")
                .withParameters<std::map<std::string, sdbus::Variant>>(
                    "share_target"),
            sdbus::registerSignal("IncomingTransfer")
                .withParameters<std::string,
                                std::map<std::string, sdbus::Variant>,
                                std::map<std::string, sdbus::Variant>>(
                    "direction", "share_target", "transfer"),
            sdbus::registerSignal("TransferUpdate")
                .withParameters<std::string,
                                std::map<std::string, sdbus::Variant>,
                                std::map<std::string, sdbus::Variant>>(
                    "direction", "share_target", "transfer"),
            sdbus::registerSignal("StatusChanged")
                .withParameters<std::map<std::string, sdbus::Variant>>(
                    "status"))
        .forInterface(INTERFACE_NAME);
  }

 public:
  void emitTargetDiscovered(
      const std::map<std::string, sdbus::Variant>& share_target) {
    m_object.emitSignal("TargetDiscovered")
        .onInterface(INTERFACE_NAME)
        .withArguments(share_target);
  }

  void emitTargetUpdated(
      const std::map<std::string, sdbus::Variant>& share_target) {
    m_object.emitSignal("TargetUpdated")
        .onInterface(INTERFACE_NAME)
        .withArguments(share_target);
  }

  void emitTargetLost(
      const std::map<std::string, sdbus::Variant>& share_target) {
    m_object.emitSignal("TargetLost")
        .onInterface(INTERFACE_NAME)
        .withArguments(share_target);
  }

  void emitIncomingTransfer(
      const std::string& direction,
      const std::map<std::string, sdbus::Variant>& share_target,
      const std::map<std::string, sdbus::Variant>& transfer) {
    m_object.emitSignal("IncomingTransfer")
        .onInterface(INTERFACE_NAME)
        .withArguments(direction, share_target, transfer);
  }

  void emitTransferUpdate(
      const std::string& direction,
      const std::map<std::string, sdbus::Variant>& share_target,
      const std::map<std::string, sdbus::Variant>& transfer) {
    m_object.emitSignal("TransferUpdate")
        .onInterface(INTERFACE_NAME)
        .withArguments(direction, share_target, transfer);
  }

  void emitStatusChanged(const std::map<std::string, sdbus::Variant>& status) {
    m_object.emitSignal("StatusChanged")
        .onInterface(INTERFACE_NAME)
        .withArguments(status);
  }

 private:
  virtual std::tuple<bool, std::string> StartReceive() = 0;
  virtual std::tuple<bool, std::string> StopReceive() = 0;
  virtual std::tuple<bool, std::string> StartDiscovery() = 0;
  virtual std::tuple<bool, std::string> StopDiscovery() = 0;
  virtual std::tuple<bool, std::string> SendFile(const int64_t& share_target_id,
                                                 const std::string& path) = 0;
  virtual std::tuple<bool, std::string> Accept(
      const int64_t& share_target_id) = 0;
  virtual std::tuple<bool, std::string> Reject(
      const int64_t& share_target_id) = 0;
  virtual std::tuple<bool, std::string> Cancel(
      const int64_t& share_target_id) = 0;
  virtual std::tuple<bool, std::string> Shutdown() = 0;

 private:
  sdbus::IObject& m_object;
};

}  // namespace nearby
}  // namespace google
}  // namespace com

#endif