TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-14 14:46:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

generated sdbus v2 bindings

Browse Source
This commit is contained in:
lasan
2026-03-19 17:59:19 +05:30
parent 2b63435a42
commit 4cc3bec2aa
28 changed files with 763 additions and 1184 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/platform/implementation/linux/generated/dbus/avahi/entrygroup_client.h
-94
View File
@@ -1,94 +0,0 @@
/*
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__avahi_entrygroup_client_glue_h__proxy__H__
#define __sdbuscpp__avahi_entrygroup_client_glue_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>
namespace org {
namespace freedesktop {
namespace Avahi {
class EntryGroup_proxy
{
public:
static constexpr const char* INTERFACE_NAME = "org.freedesktop.Avahi.EntryGroup";
protected:
EntryGroup_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
{
proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const int32_t& state, const std::string& error){ this->onStateChanged(state, error); });
}
~EntryGroup_proxy() = default;
virtual void onStateChanged(const int32_t& state, const std::string& error) = 0;
public:
void Free()
{
proxy_.callMethod("Free").onInterface(INTERFACE_NAME);
}
void Commit()
{
proxy_.callMethod("Commit").onInterface(INTERFACE_NAME);
}
void Reset()
{
proxy_.callMethod("Reset").onInterface(INTERFACE_NAME);
}
int32_t GetState()
{
int32_t result;
proxy_.callMethod("GetState").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
bool IsEmpty()
{
bool result;
proxy_.callMethod("IsEmpty").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void AddService(const int32_t& interface, const int32_t& protocol, const uint32_t& flags, const std::string& name, const std::string& type, const std::string& domain, const std::string& host, const uint16_t& port, const std::vector<std::vector<uint8_t>>& txt)
{
proxy_.callMethod("AddService").onInterface(INTERFACE_NAME).withArguments(interface, protocol, flags, name, type, domain, host, port, txt);
}
void AddServiceSubtype(const int32_t& interface, const int32_t& protocol, const uint32_t& flags, const std::string& name, const std::string& type, const std::string& domain, const std::string& subtype)
{
proxy_.callMethod("AddServiceSubtype").onInterface(INTERFACE_NAME).withArguments(interface, protocol, flags, name, type, domain, subtype);
}
void UpdateServiceTxt(const int32_t& interface, const int32_t& protocol, const uint32_t& flags, const std::string& name, const std::string& type, const std::string& domain, const std::vector<std::vector<uint8_t>>& txt)
{
proxy_.callMethod("UpdateServiceTxt").onInterface(INTERFACE_NAME).withArguments(interface, protocol, flags, name, type, domain, txt);
}
void AddAddress(const int32_t& interface, const int32_t& protocol, const uint32_t& flags, const std::string& name, const std::string& address)
{
proxy_.callMethod("AddAddress").onInterface(INTERFACE_NAME).withArguments(interface, protocol, flags, name, address);
}
void AddRecord(const int32_t& interface, const int32_t& protocol, const uint32_t& flags, const std::string& name, const uint16_t& clazz, const uint16_t& type, const uint32_t& ttl, const std::vector<uint8_t>& rdata)
{
proxy_.callMethod("AddRecord").onInterface(INTERFACE_NAME).withArguments(interface, protocol, flags, name, clazz, type, ttl, rdata);
}
private:
sdbus::IProxy& proxy_;
};
}}} // namespaces
#endif
internal/platform/implementation/linux/generated/dbus/avahi/server2_client.h
-409
View File
@@ -1,409 +0,0 @@
/*
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_avahi_server2_client_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_avahi_server2_client_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>
namespace org {
namespace freedesktop {
namespace Avahi {
class Server_proxy
{
public:
static constexpr const char* INTERFACE_NAME = "org.freedesktop.Avahi.Server";
protected:
Server_proxy(sdbus::IProxy& proxy)
: proxy_(&proxy)
{
proxy_->uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const int32_t& state, const std::string& error){ this->onStateChanged(state, error); });
}
Server_proxy(const Server_proxy&) = delete;
Server_proxy& operator=(const Server_proxy&) = delete;
Server_proxy(Server_proxy&&) = default;
Server_proxy& operator=(Server_proxy&&) = default;
~Server_proxy() = default;
virtual void onStateChanged(const int32_t& state, const std::string& error) = 0;
virtual void onResolveServiceReply(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const std::string& host, const int32_t& aprotocol, const std::string& address, const uint16_t& port, const std::vector<std::vector<uint8_t>>& txt, const uint32_t& flags, const sdbus::Error* error) = 0;
public:
std::string GetVersionString()
{
std::string result;
proxy_->callMethod("GetVersionString").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t GetAPIVersion()
{
uint32_t result;
proxy_->callMethod("GetAPIVersion").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetHostName()
{
std::string result;
proxy_->callMethod("GetHostName").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetHostName(const std::string& name)
{
proxy_->callMethod("SetHostName").onInterface(INTERFACE_NAME).withArguments(name);
}
std::string GetHostNameFqdn()
{
std::string result;
proxy_->callMethod("GetHostNameFqdn").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetDomainName()
{
std::string result;
proxy_->callMethod("GetDomainName").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
bool IsNSSSupportAvailable()
{
bool result;
proxy_->callMethod("IsNSSSupportAvailable").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
int32_t GetState()
{
int32_t result;
proxy_->callMethod("GetState").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t GetLocalServiceCookie()
{
uint32_t result;
proxy_->callMethod("GetLocalServiceCookie").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetAlternativeHostName(const std::string& name)
{
std::string result;
proxy_->callMethod("GetAlternativeHostName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::string GetAlternativeServiceName(const std::string& name)
{
std::string result;
proxy_->callMethod("GetAlternativeServiceName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::string GetNetworkInterfaceNameByIndex(const int32_t& index)
{
std::string result;
proxy_->callMethod("GetNetworkInterfaceNameByIndex").onInterface(INTERFACE_NAME).withArguments(index).storeResultsTo(result);
return result;
}
int32_t GetNetworkInterfaceIndexByName(const std::string& name)
{
int32_t result;
proxy_->callMethod("GetNetworkInterfaceIndexByName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::tuple<int32_t, int32_t, std::string, int32_t, std::string, uint32_t> ResolveHostName(const int32_t& interface, const int32_t& protocol, const std::string& name, const int32_t& aprotocol, const uint32_t& flags)
{
std::tuple<int32_t, int32_t, std::string, int32_t, std::string, uint32_t> result;
proxy_->callMethod("ResolveHostName").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, aprotocol, flags).storeResultsTo(result);
return result;
}
std::tuple<int32_t, int32_t, int32_t, std::string, std::string, uint32_t> ResolveAddress(const int32_t& interface, const int32_t& protocol, const std::string& address, const uint32_t& flags)
{
std::tuple<int32_t, int32_t, int32_t, std::string, std::string, uint32_t> result;
proxy_->callMethod("ResolveAddress").onInterface(INTERFACE_NAME).withArguments(interface, protocol, address, flags).storeResultsTo(result);
return result;
}
sdbus::PendingAsyncCall ResolveService(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const int32_t& aprotocol, const uint32_t& flags)
{
return proxy_->callMethodAsync("ResolveService").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, type, domain, aprotocol, flags).uponReplyInvoke([this](const sdbus::Error* error, const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const std::string& host, const int32_t& aprotocol, const std::string& address, const uint16_t& port, const std::vector<std::vector<uint8_t>>& txt, const uint32_t& flags){ this->onResolveServiceReply(interface, protocol, name, type, domain, host, aprotocol, address, port, txt, flags, error); });
}
sdbus::ObjectPath EntryGroupNew()
{
sdbus::ObjectPath result;
proxy_->callMethod("EntryGroupNew").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
sdbus::ObjectPath DomainBrowserNew(const int32_t& interface, const int32_t& protocol, const std::string& domain, const int32_t& btype, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("DomainBrowserNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, domain, btype, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceTypeBrowserNew(const int32_t& interface, const int32_t& protocol, const std::string& domain, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceTypeBrowserNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, domain, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceBrowserNew(const int32_t& interface, const int32_t& protocol, const std::string& type, const std::string& domain, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceBrowserNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, type, domain, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceResolverNew(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const int32_t& aprotocol, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceResolverNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, type, domain, aprotocol, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath HostNameResolverNew(const int32_t& interface, const int32_t& protocol, const std::string& name, const int32_t& aprotocol, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("HostNameResolverNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, aprotocol, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath AddressResolverNew(const int32_t& interface, const int32_t& protocol, const std::string& address, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("AddressResolverNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, address, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath RecordBrowserNew(const int32_t& interface, const int32_t& protocol, const std::string& name, const uint16_t& clazz, const uint16_t& type, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("RecordBrowserNew").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, clazz, type, flags).storeResultsTo(result);
return result;
}
private:
sdbus::IProxy* proxy_;
};
}}} // namespaces
namespace org {
namespace freedesktop {
namespace Avahi {
class Server2_proxy
{
public:
static constexpr const char* INTERFACE_NAME = "org.freedesktop.Avahi.Server2";
protected:
Server2_proxy(sdbus::IProxy& proxy)
: proxy_(&proxy)
{
proxy_->uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const int32_t& state, const std::string& error){ this->onStateChanged(state, error); });
}
Server2_proxy(const Server2_proxy&) = delete;
Server2_proxy& operator=(const Server2_proxy&) = delete;
Server2_proxy(Server2_proxy&&) = default;
Server2_proxy& operator=(Server2_proxy&&) = default;
~Server2_proxy() = default;
virtual void onStateChanged(const int32_t& state, const std::string& error) = 0;
virtual void onResolveServiceReply(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const std::string& host, const int32_t& aprotocol, const std::string& address, const uint16_t& port, const std::vector<std::vector<uint8_t>>& txt, const uint32_t& flags, const sdbus::Error* error) = 0;
public:
std::string GetVersionString()
{
std::string result;
proxy_->callMethod("GetVersionString").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t GetAPIVersion()
{
uint32_t result;
proxy_->callMethod("GetAPIVersion").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetHostName()
{
std::string result;
proxy_->callMethod("GetHostName").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetHostName(const std::string& name)
{
proxy_->callMethod("SetHostName").onInterface(INTERFACE_NAME).withArguments(name);
}
std::string GetHostNameFqdn()
{
std::string result;
proxy_->callMethod("GetHostNameFqdn").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetDomainName()
{
std::string result;
proxy_->callMethod("GetDomainName").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
bool IsNSSSupportAvailable()
{
bool result;
proxy_->callMethod("IsNSSSupportAvailable").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
int32_t GetState()
{
int32_t result;
proxy_->callMethod("GetState").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t GetLocalServiceCookie()
{
uint32_t result;
proxy_->callMethod("GetLocalServiceCookie").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string GetAlternativeHostName(const std::string& name)
{
std::string result;
proxy_->callMethod("GetAlternativeHostName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::string GetAlternativeServiceName(const std::string& name)
{
std::string result;
proxy_->callMethod("GetAlternativeServiceName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::string GetNetworkInterfaceNameByIndex(const int32_t& index)
{
std::string result;
proxy_->callMethod("GetNetworkInterfaceNameByIndex").onInterface(INTERFACE_NAME).withArguments(index).storeResultsTo(result);
return result;
}
int32_t GetNetworkInterfaceIndexByName(const std::string& name)
{
int32_t result;
proxy_->callMethod("GetNetworkInterfaceIndexByName").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
return result;
}
std::tuple<int32_t, int32_t, std::string, int32_t, std::string, uint32_t> ResolveHostName(const int32_t& interface, const int32_t& protocol, const std::string& name, const int32_t& aprotocol, const uint32_t& flags)
{
std::tuple<int32_t, int32_t, std::string, int32_t, std::string, uint32_t> result;
proxy_->callMethod("ResolveHostName").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, aprotocol, flags).storeResultsTo(result);
return result;
}
std::tuple<int32_t, int32_t, int32_t, std::string, std::string, uint32_t> ResolveAddress(const int32_t& interface, const int32_t& protocol, const std::string& address, const uint32_t& flags)
{
std::tuple<int32_t, int32_t, int32_t, std::string, std::string, uint32_t> result;
proxy_->callMethod("ResolveAddress").onInterface(INTERFACE_NAME).withArguments(interface, protocol, address, flags).storeResultsTo(result);
return result;
}
sdbus::PendingAsyncCall ResolveService(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const int32_t& aprotocol, const uint32_t& flags)
{
return proxy_->callMethodAsync("ResolveService").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, type, domain, aprotocol, flags).uponReplyInvoke([this](const sdbus::Error* error, const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const std::string& host, const int32_t& aprotocol, const std::string& address, const uint16_t& port, const std::vector<std::vector<uint8_t>>& txt, const uint32_t& flags){ this->onResolveServiceReply(interface, protocol, name, type, domain, host, aprotocol, address, port, txt, flags, error); });
}
sdbus::ObjectPath EntryGroupNew()
{
sdbus::ObjectPath result;
proxy_->callMethod("EntryGroupNew").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
sdbus::ObjectPath DomainBrowserPrepare(const int32_t& interface, const int32_t& protocol, const std::string& domain, const int32_t& btype, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("DomainBrowserPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, domain, btype, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceTypeBrowserPrepare(const int32_t& interface, const int32_t& protocol, const std::string& domain, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceTypeBrowserPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, domain, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceBrowserPrepare(const int32_t& interface, const int32_t& protocol, const std::string& type, const std::string& domain, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceBrowserPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, type, domain, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ServiceResolverPrepare(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const int32_t& aprotocol, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("ServiceResolverPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, type, domain, aprotocol, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath HostNameResolverPrepare(const int32_t& interface, const int32_t& protocol, const std::string& name, const int32_t& aprotocol, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("HostNameResolverPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, aprotocol, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath AddressResolverPrepare(const int32_t& interface, const int32_t& protocol, const std::string& address, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("AddressResolverPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, address, flags).storeResultsTo(result);
return result;
}
sdbus::ObjectPath RecordBrowserPrepare(const int32_t& interface, const int32_t& protocol, const std::string& name, const uint16_t& clazz, const uint16_t& type, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_->callMethod("RecordBrowserPrepare").onInterface(INTERFACE_NAME).withArguments(interface, protocol, name, clazz, type, flags).storeResultsTo(result);
return result;
}
private:
sdbus::IProxy* proxy_;
};
}}} // namespaces
#endif
internal/platform/implementation/linux/generated/dbus/avahi/servicebrowser_client.h
-58
View File
@@ -1,58 +0,0 @@
/*
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__avahi_servicebrowser_client_glue_h__proxy__H__
#define __sdbuscpp__avahi_servicebrowser_client_glue_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>
namespace org {
namespace freedesktop {
namespace Avahi {
class ServiceBrowser_proxy
{
public:
static constexpr const char* INTERFACE_NAME = "org.freedesktop.Avahi.ServiceBrowser";
protected:
ServiceBrowser_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
{
proxy_.uponSignal("ItemNew").onInterface(INTERFACE_NAME).call([this](const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const uint32_t& flags){ this->onItemNew(interface, protocol, name, type, domain, flags); });
proxy_.uponSignal("ItemRemove").onInterface(INTERFACE_NAME).call([this](const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const uint32_t& flags){ this->onItemRemove(interface, protocol, name, type, domain, flags); });
proxy_.uponSignal("Failure").onInterface(INTERFACE_NAME).call([this](const std::string& error){ this->onFailure(error); });
proxy_.uponSignal("AllForNow").onInterface(INTERFACE_NAME).call([this](){ this->onAllForNow(); });
proxy_.uponSignal("CacheExhausted").onInterface(INTERFACE_NAME).call([this](){ this->onCacheExhausted(); });
}
~ServiceBrowser_proxy() = default;
virtual void onItemNew(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const uint32_t& flags) = 0;
virtual void onItemRemove(const int32_t& interface, const int32_t& protocol, const std::string& name, const std::string& type, const std::string& domain, const uint32_t& flags) = 0;
virtual void onFailure(const std::string& error) = 0;
virtual void onAllForNow() = 0;
virtual void onCacheExhausted() = 0;
public:
void Free()
{
proxy_.callMethod("Free").onInterface(INTERFACE_NAME);
}
void Start()
{
proxy_.callMethod("Start").onInterface(INTERFACE_NAME);
}
private:
sdbus::IProxy& proxy_;
};
}}} // namespaces
#endif
internal/platform/implementation/linux/generated/dbus/bluez/adapter_client.h
+41 -32
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__bluez_adapter_client_glue_h__proxy__H__
#define __sdbuscpp__bluez_adapter_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_adapter_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_adapter_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,158 +20,167 @@ public:
protected:
Adapter1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
Adapter1_proxy(const Adapter1_proxy&) = delete;
Adapter1_proxy& operator=(const Adapter1_proxy&) = delete;
Adapter1_proxy(Adapter1_proxy&&) = delete;
Adapter1_proxy& operator=(Adapter1_proxy&&) = delete;
~Adapter1_proxy() = default;
void registerProxy()
{
}
public:
void StartDiscovery()
{
proxy_.callMethod("StartDiscovery").onInterface(INTERFACE_NAME);
m_proxy.callMethod("StartDiscovery").onInterface(INTERFACE_NAME);
}
void SetDiscoveryFilter(const std::map<std::string, sdbus::Variant>& properties)
{
proxy_.callMethod("SetDiscoveryFilter").onInterface(INTERFACE_NAME).withArguments(properties);
m_proxy.callMethod("SetDiscoveryFilter").onInterface(INTERFACE_NAME).withArguments(properties);
}
void StopDiscovery()
{
proxy_.callMethod("StopDiscovery").onInterface(INTERFACE_NAME);
m_proxy.callMethod("StopDiscovery").onInterface(INTERFACE_NAME);
}
void RemoveDevice(const sdbus::ObjectPath& device)
{
proxy_.callMethod("RemoveDevice").onInterface(INTERFACE_NAME).withArguments(device);
m_proxy.callMethod("RemoveDevice").onInterface(INTERFACE_NAME).withArguments(device);
}
std::vector<std::string> GetDiscoveryFilters()
{
std::vector<std::string> result;
proxy_.callMethod("GetDiscoveryFilters").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetDiscoveryFilters").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void ConnectDevice(const std::map<std::string, sdbus::Variant>& properties)
{
proxy_.callMethod("ConnectDevice").onInterface(INTERFACE_NAME).withArguments(properties);
m_proxy.callMethod("ConnectDevice").onInterface(INTERFACE_NAME).withArguments(properties);
}
public:
std::string Address()
{
return proxy_.getProperty("Address").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Address").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string AddressType()
{
return proxy_.getProperty("AddressType").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AddressType").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Name()
{
return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Name").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Alias()
{
return proxy_.getProperty("Alias").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Alias").onInterface(INTERFACE_NAME).get<std::string>();
}
void Alias(const std::string& value)
{
proxy_.setProperty("Alias").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Alias").onInterface(INTERFACE_NAME).toValue(value);
}
uint32_t Class()
{
return proxy_.getProperty("Class").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Class").onInterface(INTERFACE_NAME).get<uint32_t>();
}
bool Powered()
{
return proxy_.getProperty("Powered").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Powered").onInterface(INTERFACE_NAME).get<bool>();
}
void Powered(const bool& value)
{
proxy_.setProperty("Powered").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Powered").onInterface(INTERFACE_NAME).toValue(value);
}
std::string PowerState()
{
return proxy_.getProperty("PowerState").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PowerState").onInterface(INTERFACE_NAME).get<std::string>();
}
bool Discoverable()
{
return proxy_.getProperty("Discoverable").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Discoverable").onInterface(INTERFACE_NAME).get<bool>();
}
void Discoverable(const bool& value)
{
proxy_.setProperty("Discoverable").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Discoverable").onInterface(INTERFACE_NAME).toValue(value);
}
uint32_t DiscoverableTimeout()
{
return proxy_.getProperty("DiscoverableTimeout").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("DiscoverableTimeout").onInterface(INTERFACE_NAME).get<uint32_t>();
}
void DiscoverableTimeout(const uint32_t& value)
{
proxy_.setProperty("DiscoverableTimeout").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("DiscoverableTimeout").onInterface(INTERFACE_NAME).toValue(value);
}
bool Pairable()
{
return proxy_.getProperty("Pairable").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Pairable").onInterface(INTERFACE_NAME).get<bool>();
}
void Pairable(const bool& value)
{
proxy_.setProperty("Pairable").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Pairable").onInterface(INTERFACE_NAME).toValue(value);
}
uint32_t PairableTimeout()
{
return proxy_.getProperty("PairableTimeout").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PairableTimeout").onInterface(INTERFACE_NAME).get<uint32_t>();
}
void PairableTimeout(const uint32_t& value)
{
proxy_.setProperty("PairableTimeout").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("PairableTimeout").onInterface(INTERFACE_NAME).toValue(value);
}
bool Discovering()
{
return proxy_.getProperty("Discovering").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Discovering").onInterface(INTERFACE_NAME).get<bool>();
}
std::vector<std::string> UUIDs()
{
return proxy_.getProperty("UUIDs").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("UUIDs").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::string Modalias()
{
return proxy_.getProperty("Modalias").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Modalias").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<std::string> Roles()
{
return proxy_.getProperty("Roles").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Roles").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> ExperimentalFeatures()
{
return proxy_.getProperty("ExperimentalFeatures").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ExperimentalFeatures").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/advertisement_monitor_manager_client.h
+17 -8
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__advertisement_monitor_manager_client_h__proxy__H__
#define __sdbuscpp__advertisement_monitor_manager_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_advertisement_monitor_manager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_advertisement_monitor_manager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,36 +20,45 @@ public:
protected:
AdvertisementMonitorManager1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
AdvertisementMonitorManager1_proxy(const AdvertisementMonitorManager1_proxy&) = delete;
AdvertisementMonitorManager1_proxy& operator=(const AdvertisementMonitorManager1_proxy&) = delete;
AdvertisementMonitorManager1_proxy(AdvertisementMonitorManager1_proxy&&) = delete;
AdvertisementMonitorManager1_proxy& operator=(AdvertisementMonitorManager1_proxy&&) = delete;
~AdvertisementMonitorManager1_proxy() = default;
void registerProxy()
{
}
public:
void RegisterMonitor(const sdbus::ObjectPath& application)
{
proxy_.callMethod("RegisterMonitor").onInterface(INTERFACE_NAME).withArguments(application);
m_proxy.callMethod("RegisterMonitor").onInterface(INTERFACE_NAME).withArguments(application);
}
void UnregisterMonitor(const sdbus::ObjectPath& application)
{
proxy_.callMethod("UnregisterMonitor").onInterface(INTERFACE_NAME).withArguments(application);
m_proxy.callMethod("UnregisterMonitor").onInterface(INTERFACE_NAME).withArguments(application);
}
public:
std::vector<std::string> SupportedMonitorTypes()
{
return proxy_.getProperty("SupportedMonitorTypes").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedMonitorTypes").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> SupportedFeatures()
{
return proxy_.getProperty("SupportedFeatures").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedFeatures").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/advertisement_monitor_server.h
+23 -13
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__advertisement_monitor_server_h__adaptor__H__
#define __sdbuscpp__advertisement_monitor_server_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_advertisement_monitor_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_advertisement_monitor_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,21 +20,31 @@ public:
protected:
AdvertisementMonitor1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerMethod("Release").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Release(); });
object_.registerMethod("Activate").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Activate(); });
object_.registerMethod("DeviceFound").onInterface(INTERFACE_NAME).withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->DeviceFound(device); });
object_.registerMethod("DeviceLost").onInterface(INTERFACE_NAME).withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->DeviceLost(device); });
object_.registerProperty("Type").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Type(); });
object_.registerProperty("RSSILowThreshold").onInterface(INTERFACE_NAME).withGetter([this](){ return this->RSSILowThreshold(); });
object_.registerProperty("RSSIHighThreshold").onInterface(INTERFACE_NAME).withGetter([this](){ return this->RSSIHighThreshold(); });
object_.registerProperty("RSSISamplingPeriod").onInterface(INTERFACE_NAME).withGetter([this](){ return this->RSSISamplingPeriod(); });
object_.registerProperty("Patterns").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Patterns(); });
}
AdvertisementMonitor1_adaptor(const AdvertisementMonitor1_adaptor&) = delete;
AdvertisementMonitor1_adaptor& operator=(const AdvertisementMonitor1_adaptor&) = delete;
AdvertisementMonitor1_adaptor(AdvertisementMonitor1_adaptor&&) = delete;
AdvertisementMonitor1_adaptor& operator=(AdvertisementMonitor1_adaptor&&) = delete;
~AdvertisementMonitor1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerMethod("Release").implementedAs([this](){ return this->Release(); })
, sdbus::registerMethod("Activate").implementedAs([this](){ return this->Activate(); })
, sdbus::registerMethod("DeviceFound").withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->DeviceFound(device); })
, sdbus::registerMethod("DeviceLost").withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->DeviceLost(device); })
, sdbus::registerProperty("Type").withGetter([this](){ return this->Type(); })
, sdbus::registerProperty("RSSILowThreshold").withGetter([this](){ return this->RSSILowThreshold(); })
, sdbus::registerProperty("RSSIHighThreshold").withGetter([this](){ return this->RSSIHighThreshold(); })
, sdbus::registerProperty("RSSISamplingPeriod").withGetter([this](){ return this->RSSISamplingPeriod(); })
, sdbus::registerProperty("Patterns").withGetter([this](){ return this->Patterns(); })
).forInterface(INTERFACE_NAME);
}
private:
virtual void Release() = 0;
virtual void Activate() = 0;
@@ -49,7 +59,7 @@ private:
virtual std::vector<sdbus::Struct<uint8_t, uint8_t, std::vector<uint8_t>>> Patterns() = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/device_client.h
+49 -40
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__device_client_h__proxy__H__
#define __sdbuscpp__device_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_device_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_device_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,193 +20,202 @@ public:
protected:
Device1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
Device1_proxy(const Device1_proxy&) = delete;
Device1_proxy& operator=(const Device1_proxy&) = delete;
Device1_proxy(Device1_proxy&&) = delete;
Device1_proxy& operator=(Device1_proxy&&) = delete;
~Device1_proxy() = default;
virtual void onPairReply(const sdbus::Error* error) = 0;
void registerProxy()
{
}
virtual void onPairReply(std::optional<sdbus::Error> error) = 0;
public:
void Disconnect()
{
proxy_.callMethod("Disconnect").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Disconnect").onInterface(INTERFACE_NAME);
}
void Connect()
{
proxy_.callMethod("Connect").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Connect").onInterface(INTERFACE_NAME);
}
void ConnectProfile(const std::string& UUID)
{
proxy_.callMethod("ConnectProfile").onInterface(INTERFACE_NAME).withArguments(UUID);
m_proxy.callMethod("ConnectProfile").onInterface(INTERFACE_NAME).withArguments(UUID);
}
void DisconnectProfile(const std::string& UUID)
{
proxy_.callMethod("DisconnectProfile").onInterface(INTERFACE_NAME).withArguments(UUID);
m_proxy.callMethod("DisconnectProfile").onInterface(INTERFACE_NAME).withArguments(UUID);
}
sdbus::PendingAsyncCall Pair()
{
return proxy_.callMethodAsync("Pair").onInterface(INTERFACE_NAME).uponReplyInvoke([this](const sdbus::Error* error){ this->onPairReply(error); });
return m_proxy.callMethodAsync("Pair").onInterface(INTERFACE_NAME).uponReplyInvoke([this](std::optional<sdbus::Error> error){ this->onPairReply(std::move(error)); });
}
void CancelPairing()
{
proxy_.callMethod("CancelPairing").onInterface(INTERFACE_NAME);
m_proxy.callMethod("CancelPairing").onInterface(INTERFACE_NAME);
}
public:
std::string Address()
{
return proxy_.getProperty("Address").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Address").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string AddressType()
{
return proxy_.getProperty("AddressType").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AddressType").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Name()
{
return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Name").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Alias()
{
return proxy_.getProperty("Alias").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Alias").onInterface(INTERFACE_NAME).get<std::string>();
}
void Alias(const std::string& value)
{
proxy_.setProperty("Alias").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Alias").onInterface(INTERFACE_NAME).toValue(value);
}
uint32_t Class()
{
return proxy_.getProperty("Class").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Class").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint16_t Appearance()
{
return proxy_.getProperty("Appearance").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Appearance").onInterface(INTERFACE_NAME).get<uint16_t>();
}
std::string Icon()
{
return proxy_.getProperty("Icon").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Icon").onInterface(INTERFACE_NAME).get<std::string>();
}
bool Paired()
{
return proxy_.getProperty("Paired").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Paired").onInterface(INTERFACE_NAME).get<bool>();
}
bool Bonded()
{
return proxy_.getProperty("Bonded").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Bonded").onInterface(INTERFACE_NAME).get<bool>();
}
bool Trusted()
{
return proxy_.getProperty("Trusted").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Trusted").onInterface(INTERFACE_NAME).get<bool>();
}
void Trusted(const bool& value)
{
proxy_.setProperty("Trusted").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Trusted").onInterface(INTERFACE_NAME).toValue(value);
}
bool Blocked()
{
return proxy_.getProperty("Blocked").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Blocked").onInterface(INTERFACE_NAME).get<bool>();
}
void Blocked(const bool& value)
{
proxy_.setProperty("Blocked").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("Blocked").onInterface(INTERFACE_NAME).toValue(value);
}
bool LegacyPairing()
{
return proxy_.getProperty("LegacyPairing").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("LegacyPairing").onInterface(INTERFACE_NAME).get<bool>();
}
int16_t RSSI()
{
return proxy_.getProperty("RSSI").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RSSI").onInterface(INTERFACE_NAME).get<int16_t>();
}
bool Connected()
{
return proxy_.getProperty("Connected").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Connected").onInterface(INTERFACE_NAME).get<bool>();
}
std::vector<std::string> UUIDs()
{
return proxy_.getProperty("UUIDs").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("UUIDs").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::string Modalias()
{
return proxy_.getProperty("Modalias").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Modalias").onInterface(INTERFACE_NAME).get<std::string>();
}
sdbus::ObjectPath Adapter()
{
return proxy_.getProperty("Adapter").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Adapter").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
std::map<uint16_t, sdbus::Variant> ManufacturerData()
{
return proxy_.getProperty("ManufacturerData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ManufacturerData").onInterface(INTERFACE_NAME).get<std::map<uint16_t, sdbus::Variant>>();
}
std::map<std::string, sdbus::Variant> ServiceData()
{
return proxy_.getProperty("ServiceData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ServiceData").onInterface(INTERFACE_NAME).get<std::map<std::string, sdbus::Variant>>();
}
int16_t TxPower()
{
return proxy_.getProperty("TxPower").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("TxPower").onInterface(INTERFACE_NAME).get<int16_t>();
}
bool ServicesResolved()
{
return proxy_.getProperty("ServicesResolved").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ServicesResolved").onInterface(INTERFACE_NAME).get<bool>();
}
std::vector<uint8_t> AdvertisingFlags()
{
return proxy_.getProperty("AdvertisingFlags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AdvertisingFlags").onInterface(INTERFACE_NAME).get<std::vector<uint8_t>>();
}
std::map<uint8_t, sdbus::Variant> AdvertisingData()
{
return proxy_.getProperty("AdvertisingData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AdvertisingData").onInterface(INTERFACE_NAME).get<std::map<uint8_t, sdbus::Variant>>();
}
bool WakeAllowed()
{
return proxy_.getProperty("WakeAllowed").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WakeAllowed").onInterface(INTERFACE_NAME).get<bool>();
}
void WakeAllowed(const bool& value)
{
proxy_.setProperty("WakeAllowed").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("WakeAllowed").onInterface(INTERFACE_NAME).toValue(value);
}
std::map<sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> Sets()
{
return proxy_.getProperty("Sets").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Sets").onInterface(INTERFACE_NAME).get<std::map<sdbus::ObjectPath, std::map<std::string, sdbus::Variant>>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_characteristic_client.h
+28 -19
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__gatt_characteristic_client_h__proxy__H__
#define __sdbuscpp__gatt_characteristic_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_characteristic_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_characteristic_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,97 +20,106 @@ public:
protected:
GattCharacteristic1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
GattCharacteristic1_proxy(const GattCharacteristic1_proxy&) = delete;
GattCharacteristic1_proxy& operator=(const GattCharacteristic1_proxy&) = delete;
GattCharacteristic1_proxy(GattCharacteristic1_proxy&&) = delete;
GattCharacteristic1_proxy& operator=(GattCharacteristic1_proxy&&) = delete;
~GattCharacteristic1_proxy() = default;
void registerProxy()
{
}
public:
std::vector<uint8_t> ReadValue(const std::map<std::string, sdbus::Variant>& options)
{
std::vector<uint8_t> result;
proxy_.callMethod("ReadValue").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
m_proxy.callMethod("ReadValue").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
return result;
}
void WriteValue(const std::vector<uint8_t>& value, const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("WriteValue").onInterface(INTERFACE_NAME).withArguments(value, options);
m_proxy.callMethod("WriteValue").onInterface(INTERFACE_NAME).withArguments(value, options);
}
std::tuple<sdbus::UnixFd, uint16_t> AcquireWrite(const std::map<std::string, sdbus::Variant>& options)
{
std::tuple<sdbus::UnixFd, uint16_t> result;
proxy_.callMethod("AcquireWrite").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
m_proxy.callMethod("AcquireWrite").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
return result;
}
std::tuple<sdbus::UnixFd, uint16_t> AcquireNotify(const std::map<std::string, sdbus::Variant>& options)
{
std::tuple<sdbus::UnixFd, uint16_t> result;
proxy_.callMethod("AcquireNotify").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
m_proxy.callMethod("AcquireNotify").onInterface(INTERFACE_NAME).withArguments(options).storeResultsTo(result);
return result;
}
void StartNotify()
{
proxy_.callMethod("StartNotify").onInterface(INTERFACE_NAME);
m_proxy.callMethod("StartNotify").onInterface(INTERFACE_NAME);
}
void StopNotify()
{
proxy_.callMethod("StopNotify").onInterface(INTERFACE_NAME);
m_proxy.callMethod("StopNotify").onInterface(INTERFACE_NAME);
}
public:
uint16_t Handle()
{
return proxy_.getProperty("Handle").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Handle").onInterface(INTERFACE_NAME).get<uint16_t>();
}
std::string UUID()
{
return proxy_.getProperty("UUID").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("UUID").onInterface(INTERFACE_NAME).get<std::string>();
}
sdbus::ObjectPath Service()
{
return proxy_.getProperty("Service").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Service").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
std::vector<uint8_t> Value()
{
return proxy_.getProperty("Value").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Value").onInterface(INTERFACE_NAME).get<std::vector<uint8_t>>();
}
bool Notifying()
{
return proxy_.getProperty("Notifying").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Notifying").onInterface(INTERFACE_NAME).get<bool>();
}
std::vector<std::string> Flags()
{
return proxy_.getProperty("Flags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Flags").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
bool WriteAcquired()
{
return proxy_.getProperty("WriteAcquired").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WriteAcquired").onInterface(INTERFACE_NAME).get<bool>();
}
bool NotifyAcquired()
{
return proxy_.getProperty("NotifyAcquired").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NotifyAcquired").onInterface(INTERFACE_NAME).get<bool>();
}
uint16_t MTU()
{
return proxy_.getProperty("MTU").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("MTU").onInterface(INTERFACE_NAME).get<uint16_t>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_characteristic_server.h
+24 -14
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__generated_dbus_bluez_gatt_characteristic_server_h__adaptor__H__
#define __sdbuscpp__generated_dbus_bluez_gatt_characteristic_server_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_characteristic_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_characteristic_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,22 +20,32 @@ public:
protected:
GattCharacteristic1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerMethod("ReadValue").onInterface(INTERFACE_NAME).withInputParamNames("options").withOutputParamNames("value").implementedAs([this](sdbus::Result<std::vector<uint8_t>>&& result, std::map<std::string, sdbus::Variant> options){ this->ReadValue(std::move(result), std::move(options)); });
object_.registerMethod("WriteValue").onInterface(INTERFACE_NAME).withInputParamNames("value", "options").implementedAs([this](sdbus::Result<>&& result, std::vector<uint8_t> value, std::map<std::string, sdbus::Variant> options){ this->WriteValue(std::move(result), std::move(value), std::move(options)); });
object_.registerMethod("StartNotify").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->StartNotify(); });
object_.registerMethod("StopNotify").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->StopNotify(); });
object_.registerMethod("Confirm").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Confirm(); });
object_.registerProperty("UUID").onInterface(INTERFACE_NAME).withGetter([this](){ return this->UUID(); });
object_.registerProperty("Service").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Service(); });
object_.registerProperty("Value").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Value(); });
object_.registerProperty("Notifying").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Notifying(); });
object_.registerProperty("Flags").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Flags(); });
}
GattCharacteristic1_adaptor(const GattCharacteristic1_adaptor&) = delete;
GattCharacteristic1_adaptor& operator=(const GattCharacteristic1_adaptor&) = delete;
GattCharacteristic1_adaptor(GattCharacteristic1_adaptor&&) = delete;
GattCharacteristic1_adaptor& operator=(GattCharacteristic1_adaptor&&) = delete;
~GattCharacteristic1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerMethod("ReadValue").withInputParamNames("options").withOutputParamNames("value").implementedAs([this](sdbus::Result<std::vector<uint8_t>>&& result, std::map<std::string, sdbus::Variant> options){ this->ReadValue(std::move(result), std::move(options)); })
, sdbus::registerMethod("WriteValue").withInputParamNames("value", "options").implementedAs([this](sdbus::Result<>&& result, std::vector<uint8_t> value, std::map<std::string, sdbus::Variant> options){ this->WriteValue(std::move(result), std::move(value), std::move(options)); })
, sdbus::registerMethod("StartNotify").implementedAs([this](){ return this->StartNotify(); })
, sdbus::registerMethod("StopNotify").implementedAs([this](){ return this->StopNotify(); })
, sdbus::registerMethod("Confirm").implementedAs([this](){ return this->Confirm(); })
, sdbus::registerProperty("UUID").withGetter([this](){ return this->UUID(); })
, sdbus::registerProperty("Service").withGetter([this](){ return this->Service(); })
, sdbus::registerProperty("Value").withGetter([this](){ return this->Value(); })
, sdbus::registerProperty("Notifying").withGetter([this](){ return this->Notifying(); })
, sdbus::registerProperty("Flags").withGetter([this](){ return this->Flags(); })
).forInterface(INTERFACE_NAME);
}
private:
virtual void ReadValue(sdbus::Result<std::vector<uint8_t>>&& result, std::map<std::string, sdbus::Variant> options) = 0;
virtual void WriteValue(sdbus::Result<>&& result, std::vector<uint8_t> value, std::map<std::string, sdbus::Variant> options) = 0;
@@ -51,7 +61,7 @@ private:
virtual std::vector<std::string> Flags() = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_manager_client.h
+15 -6
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__gatt_manager_client_h__proxy__H__
#define __sdbuscpp__gatt_manager_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_manager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_manager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,25 +20,34 @@ public:
protected:
GattManager1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
GattManager1_proxy(const GattManager1_proxy&) = delete;
GattManager1_proxy& operator=(const GattManager1_proxy&) = delete;
GattManager1_proxy(GattManager1_proxy&&) = delete;
GattManager1_proxy& operator=(GattManager1_proxy&&) = delete;
~GattManager1_proxy() = default;
void registerProxy()
{
}
public:
void RegisterApplication(const sdbus::ObjectPath& application, const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("RegisterApplication").onInterface(INTERFACE_NAME).withArguments(application, options);
m_proxy.callMethod("RegisterApplication").onInterface(INTERFACE_NAME).withArguments(application, options);
}
void UnregisterApplication(const sdbus::ObjectPath& application)
{
proxy_.callMethod("UnregisterApplication").onInterface(INTERFACE_NAME).withArguments(application);
m_proxy.callMethod("UnregisterApplication").onInterface(INTERFACE_NAME).withArguments(application);
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_profile_server.h
+13 -8
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_profile_server_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_profile_server_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_profile_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_profile_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,19 +20,24 @@ public:
protected:
GattProfile1_adaptor(sdbus::IObject& object)
: object_(&object)
: m_object(object)
{
object_->registerMethod("Release").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Release(); });
object_->registerProperty("UUIDs").onInterface(INTERFACE_NAME).withGetter([this](){ return this->UUIDs(); });
}
GattProfile1_adaptor(const GattProfile1_adaptor&) = delete;
GattProfile1_adaptor& operator=(const GattProfile1_adaptor&) = delete;
GattProfile1_adaptor(GattProfile1_adaptor&&) = default;
GattProfile1_adaptor& operator=(GattProfile1_adaptor&&) = default;
GattProfile1_adaptor(GattProfile1_adaptor&&) = delete;
GattProfile1_adaptor& operator=(GattProfile1_adaptor&&) = delete;
~GattProfile1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerMethod("Release").implementedAs([this](){ return this->Release(); })
, sdbus::registerProperty("UUIDs").withGetter([this](){ return this->UUIDs(); })
).forInterface(INTERFACE_NAME);
}
private:
virtual void Release() = 0;
@@ -40,7 +45,7 @@ private:
virtual std::vector<std::string> UUIDs() = 0;
private:
sdbus::IObject* object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_service_client.h
+17 -8
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__gatt_service_client_h__proxy__H__
#define __sdbuscpp__gatt_service_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_service_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_service_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,35 +20,44 @@ public:
protected:
GattService1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
GattService1_proxy(const GattService1_proxy&) = delete;
GattService1_proxy& operator=(const GattService1_proxy&) = delete;
GattService1_proxy(GattService1_proxy&&) = delete;
GattService1_proxy& operator=(GattService1_proxy&&) = delete;
~GattService1_proxy() = default;
void registerProxy()
{
}
public:
std::string UUID()
{
return proxy_.getProperty("UUID").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("UUID").onInterface(INTERFACE_NAME).get<std::string>();
}
bool Primary()
{
return proxy_.getProperty("Primary").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Primary").onInterface(INTERFACE_NAME).get<bool>();
}
sdbus::ObjectPath Device()
{
return proxy_.getProperty("Device").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Device").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
std::vector<sdbus::ObjectPath> Includes()
{
return proxy_.getProperty("Includes").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Includes").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/gatt_service_server.h
+18 -8
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__generated_dbus_bluez_gatt_service_server_h__adaptor__H__
#define __sdbuscpp__generated_dbus_bluez_gatt_service_server_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_service_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_gatt_service_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,16 +20,26 @@ public:
protected:
GattService1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerProperty("UUID").onInterface(INTERFACE_NAME).withGetter([this](){ return this->UUID(); });
object_.registerProperty("Primary").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Primary(); });
object_.registerProperty("Device").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Device(); });
object_.registerProperty("Includes").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Includes(); });
}
GattService1_adaptor(const GattService1_adaptor&) = delete;
GattService1_adaptor& operator=(const GattService1_adaptor&) = delete;
GattService1_adaptor(GattService1_adaptor&&) = delete;
GattService1_adaptor& operator=(GattService1_adaptor&&) = delete;
~GattService1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerProperty("UUID").withGetter([this](){ return this->UUID(); })
, sdbus::registerProperty("Primary").withGetter([this](){ return this->Primary(); })
, sdbus::registerProperty("Device").withGetter([this](){ return this->Device(); })
, sdbus::registerProperty("Includes").withGetter([this](){ return this->Includes(); })
).forInterface(INTERFACE_NAME);
}
private:
virtual std::string UUID() = 0;
virtual bool Primary() = 0;
@@ -37,7 +47,7 @@ private:
virtual std::vector<sdbus::ObjectPath> Includes() = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/le_advertisement_manager_client.h
+21 -12
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__generated_dbus_bluez_le_advertisement_manager_client_h__proxy__H__
#define __sdbuscpp__generated_dbus_bluez_le_advertisement_manager_client_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_advertisement_manager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_advertisement_manager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,56 +20,65 @@ public:
protected:
LEAdvertisingManager1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
LEAdvertisingManager1_proxy(const LEAdvertisingManager1_proxy&) = delete;
LEAdvertisingManager1_proxy& operator=(const LEAdvertisingManager1_proxy&) = delete;
LEAdvertisingManager1_proxy(LEAdvertisingManager1_proxy&&) = delete;
LEAdvertisingManager1_proxy& operator=(LEAdvertisingManager1_proxy&&) = delete;
~LEAdvertisingManager1_proxy() = default;
void registerProxy()
{
}
public:
void RegisterAdvertisement(const sdbus::ObjectPath& advertisement, const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("RegisterAdvertisement").onInterface(INTERFACE_NAME).withArguments(advertisement, options);
m_proxy.callMethod("RegisterAdvertisement").onInterface(INTERFACE_NAME).withArguments(advertisement, options);
}
void UnregisterAdvertisement(const sdbus::ObjectPath& service)
{
proxy_.callMethod("UnregisterAdvertisement").onInterface(INTERFACE_NAME).withArguments(service);
m_proxy.callMethod("UnregisterAdvertisement").onInterface(INTERFACE_NAME).withArguments(service);
}
public:
uint8_t ActiveInstances()
{
return proxy_.getProperty("ActiveInstances").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ActiveInstances").onInterface(INTERFACE_NAME).get<uint8_t>();
}
uint8_t SupportedInstances()
{
return proxy_.getProperty("SupportedInstances").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedInstances").onInterface(INTERFACE_NAME).get<uint8_t>();
}
std::vector<std::string> SupportedIncludes()
{
return proxy_.getProperty("SupportedIncludes").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedIncludes").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> SupportedSecondaryChannels()
{
return proxy_.getProperty("SupportedSecondaryChannels").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedSecondaryChannels").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> SupportedFeatures()
{
return proxy_.getProperty("SupportedFeatures").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedFeatures").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::map<std::string, sdbus::Variant> SupportedCapabilities()
{
return proxy_.getProperty("SupportedCapabilities").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SupportedCapabilities").onInterface(INTERFACE_NAME).get<std::map<std::string, sdbus::Variant>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/le_advertisement_server.h
+27 -19
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__generated_dbus_bluez_le_advertisement_server_h__adaptor__H__
#define __sdbuscpp__generated_dbus_bluez_le_advertisement_server_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_advertisement_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_advertisement_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,26 +20,35 @@ public:
protected:
LEAdvertisement1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerMethod("Release").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Release(); });
object_.registerProperty("Type").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Type(); });
object_.registerProperty("ServiceUUIDs").onInterface(INTERFACE_NAME).withGetter([this](){ return this->ServiceUUIDs(); });
object_.registerProperty("ManufacturerData").onInterface(INTERFACE_NAME).withGetter([this](){ return this->ManufacturerData(); });
object_.registerProperty("SolicitUUIDs").onInterface(INTERFACE_NAME).withGetter([this](){ return this->SolicitUUIDs(); });
object_.registerProperty("ServiceData").onInterface(INTERFACE_NAME).withGetter([this](){ return this->ServiceData(); });
object_.registerProperty("ScanResponseServiceData").onInterface(INTERFACE_NAME).withGetter([this](){ return this->ScanResponseServiceData(); });
object_.registerProperty("Includes").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Includes(); });
object_.registerProperty("LocalName").onInterface(INTERFACE_NAME).withGetter([this](){ return this->LocalName(); });
object_.registerProperty("Duration").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Duration(); });
object_.registerProperty("Timeout").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Timeout(); });
object_.registerProperty("MinInterval").onInterface(INTERFACE_NAME).withGetter([this](){ return this->MinInterval(); });
object_.registerProperty("MaxInterval").onInterface(INTERFACE_NAME).withGetter([this](){ return this->MaxInterval(); });
object_.registerProperty("TxPower").onInterface(INTERFACE_NAME).withGetter([this](){ return this->TxPower(); });
}
LEAdvertisement1_adaptor(const LEAdvertisement1_adaptor&) = delete;
LEAdvertisement1_adaptor& operator=(const LEAdvertisement1_adaptor&) = delete;
LEAdvertisement1_adaptor(LEAdvertisement1_adaptor&&) = delete;
LEAdvertisement1_adaptor& operator=(LEAdvertisement1_adaptor&&) = delete;
~LEAdvertisement1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerMethod("Release").implementedAs([this](){ return this->Release(); })
, sdbus::registerProperty("Type").withGetter([this](){ return this->Type(); })
, sdbus::registerProperty("ServiceUUIDs").withGetter([this](){ return this->ServiceUUIDs(); })
, sdbus::registerProperty("ManufacturerData").withGetter([this](){ return this->ManufacturerData(); })
, sdbus::registerProperty("SolicitUUIDs").withGetter([this](){ return this->SolicitUUIDs(); })
, sdbus::registerProperty("ServiceData").withGetter([this](){ return this->ServiceData(); })
, sdbus::registerProperty("Includes").withGetter([this](){ return this->Includes(); })
, sdbus::registerProperty("LocalName").withGetter([this](){ return this->LocalName(); })
, sdbus::registerProperty("Duration").withGetter([this](){ return this->Duration(); })
, sdbus::registerProperty("Timeout").withGetter([this](){ return this->Timeout(); })
, sdbus::registerProperty("MinInterval").withGetter([this](){ return this->MinInterval(); })
, sdbus::registerProperty("MaxInterval").withGetter([this](){ return this->MaxInterval(); })
, sdbus::registerProperty("TxPower").withGetter([this](){ return this->TxPower(); })
).forInterface(INTERFACE_NAME);
}
private:
virtual void Release() = 0;
@@ -49,7 +58,6 @@ private:
virtual std::map<std::string, sdbus::Variant> ManufacturerData() = 0;
virtual std::vector<std::string> SolicitUUIDs() = 0;
virtual std::map<std::string, sdbus::Variant> ServiceData() = 0;
virtual std::map<std::string, sdbus::Variant> ScanResponseServiceData() = 0;
virtual std::vector<std::string> Includes() = 0;
virtual std::string LocalName() = 0;
virtual uint16_t Duration() = 0;
@@ -59,7 +67,7 @@ private:
virtual int16_t TxPower() = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/le_bearer_client.h
-76
View File
@@ -1,76 +0,0 @@
/*
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_bearer_client_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_le_bearer_client_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>
namespace org {
namespace bluez {
namespace Bearer {
class LE1_proxy
{
public:
static constexpr const char* INTERFACE_NAME = "org.bluez.Bearer.LE1";
protected:
LE1_proxy(sdbus::IProxy& proxy)
: proxy_(&proxy)
{
proxy_->uponSignal("Disconnected").onInterface(INTERFACE_NAME).call([this](const std::string& reason, const std::string& message){ this->onDisconnected(reason, message); });
}
LE1_proxy(const LE1_proxy&) = delete;
LE1_proxy& operator=(const LE1_proxy&) = delete;
LE1_proxy(LE1_proxy&&) = default;
LE1_proxy& operator=(LE1_proxy&&) = default;
~LE1_proxy() = default;
virtual void onDisconnected(const std::string& reason, const std::string& message) = 0;
public:
void Connect()
{
proxy_->callMethod("Connect").onInterface(INTERFACE_NAME);
}
void Disconnect()
{
proxy_->callMethod("Disconnect").onInterface(INTERFACE_NAME);
}
public:
sdbus::ObjectPath Adapter()
{
return proxy_->getProperty("Adapter").onInterface(INTERFACE_NAME);
}
bool Paired()
{
return proxy_->getProperty("Paired").onInterface(INTERFACE_NAME);
}
bool Bonded()
{
return proxy_->getProperty("Bonded").onInterface(INTERFACE_NAME);
}
bool Connected()
{
return proxy_->getProperty("Connected").onInterface(INTERFACE_NAME);
}
private:
sdbus::IProxy* proxy_;
};
}}} // namespaces
#endif
internal/platform/implementation/linux/generated/dbus/bluez/profile_manager_client.h
+15 -6
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__bluez_profile_manager_client_glue_h__proxy__H__
#define __sdbuscpp__bluez_profile_manager_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_profile_manager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_profile_manager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,25 +20,34 @@ public:
protected:
ProfileManager1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
ProfileManager1_proxy(const ProfileManager1_proxy&) = delete;
ProfileManager1_proxy& operator=(const ProfileManager1_proxy&) = delete;
ProfileManager1_proxy(ProfileManager1_proxy&&) = delete;
ProfileManager1_proxy& operator=(ProfileManager1_proxy&&) = delete;
~ProfileManager1_proxy() = default;
void registerProxy()
{
}
public:
void RegisterProfile(const sdbus::ObjectPath& profile, const std::string& UUID, const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("RegisterProfile").onInterface(INTERFACE_NAME).withArguments(profile, UUID, options);
m_proxy.callMethod("RegisterProfile").onInterface(INTERFACE_NAME).withArguments(profile, UUID, options);
}
void UnregisterProfile(const sdbus::ObjectPath& profile)
{
proxy_.callMethod("UnregisterProfile").onInterface(INTERFACE_NAME).withArguments(profile);
m_proxy.callMethod("UnregisterProfile").onInterface(INTERFACE_NAME).withArguments(profile);
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/bluez/profile_server.h
+17 -7
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__bluez_profile_glue_h__adaptor__H__
#define __sdbuscpp__bluez_profile_glue_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_profile_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_bluez_profile_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,22 +20,32 @@ public:
protected:
Profile1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerMethod("Release").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->Release(); });
object_.registerMethod("NewConnection").onInterface(INTERFACE_NAME).withInputParamNames("device", "fd", "fd_properties").implementedAs([this](const sdbus::ObjectPath& device, const sdbus::UnixFd& fd, const std::map<std::string, sdbus::Variant>& fd_properties){ return this->NewConnection(device, fd, fd_properties); });
object_.registerMethod("RequestDisconnection").onInterface(INTERFACE_NAME).withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->RequestDisconnection(device); });
}
Profile1_adaptor(const Profile1_adaptor&) = delete;
Profile1_adaptor& operator=(const Profile1_adaptor&) = delete;
Profile1_adaptor(Profile1_adaptor&&) = delete;
Profile1_adaptor& operator=(Profile1_adaptor&&) = delete;
~Profile1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerMethod("Release").implementedAs([this](){ return this->Release(); })
, sdbus::registerMethod("NewConnection").withInputParamNames("device", "fd", "fd_properties").implementedAs([this](const sdbus::ObjectPath& device, const sdbus::UnixFd& fd, const std::map<std::string, sdbus::Variant>& fd_properties){ return this->NewConnection(device, fd, fd_properties); })
, sdbus::registerMethod("RequestDisconnection").withInputParamNames("device").implementedAs([this](const sdbus::ObjectPath& device){ return this->RequestDisconnection(device); })
).forInterface(INTERFACE_NAME);
}
private:
virtual void Release() = 0;
virtual void NewConnection(const sdbus::ObjectPath& device, const sdbus::UnixFd& fd, const std::map<std::string, sdbus::Variant>& fd_properties) = 0;
virtual void RequestDisconnection(const sdbus::ObjectPath& device) = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/hostname/hostname_client.h
+44 -35
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__hostname_client_glue_h__proxy__H__
#define __sdbuscpp__hostname_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_hostname_hostname_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_hostname_hostname_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,177 +20,186 @@ public:
protected:
hostname1_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
hostname1_proxy(const hostname1_proxy&) = delete;
hostname1_proxy& operator=(const hostname1_proxy&) = delete;
hostname1_proxy(hostname1_proxy&&) = delete;
hostname1_proxy& operator=(hostname1_proxy&&) = delete;
~hostname1_proxy() = default;
void registerProxy()
{
}
public:
void SetHostname(const std::string& hostname, const bool& interactive)
{
proxy_.callMethod("SetHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
m_proxy.callMethod("SetHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
}
void SetStaticHostname(const std::string& hostname, const bool& interactive)
{
proxy_.callMethod("SetStaticHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
m_proxy.callMethod("SetStaticHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
}
void SetPrettyHostname(const std::string& hostname, const bool& interactive)
{
proxy_.callMethod("SetPrettyHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
m_proxy.callMethod("SetPrettyHostname").onInterface(INTERFACE_NAME).withArguments(hostname, interactive);
}
void SetIconName(const std::string& icon, const bool& interactive)
{
proxy_.callMethod("SetIconName").onInterface(INTERFACE_NAME).withArguments(icon, interactive);
m_proxy.callMethod("SetIconName").onInterface(INTERFACE_NAME).withArguments(icon, interactive);
}
void SetChassis(const std::string& chassis, const bool& interactive)
{
proxy_.callMethod("SetChassis").onInterface(INTERFACE_NAME).withArguments(chassis, interactive);
m_proxy.callMethod("SetChassis").onInterface(INTERFACE_NAME).withArguments(chassis, interactive);
}
void SetDeployment(const std::string& deployment, const bool& interactive)
{
proxy_.callMethod("SetDeployment").onInterface(INTERFACE_NAME).withArguments(deployment, interactive);
m_proxy.callMethod("SetDeployment").onInterface(INTERFACE_NAME).withArguments(deployment, interactive);
}
void SetLocation(const std::string& location, const bool& interactive)
{
proxy_.callMethod("SetLocation").onInterface(INTERFACE_NAME).withArguments(location, interactive);
m_proxy.callMethod("SetLocation").onInterface(INTERFACE_NAME).withArguments(location, interactive);
}
std::vector<uint8_t> GetProductUUID(const bool& interactive)
{
std::vector<uint8_t> result;
proxy_.callMethod("GetProductUUID").onInterface(INTERFACE_NAME).withArguments(interactive).storeResultsTo(result);
m_proxy.callMethod("GetProductUUID").onInterface(INTERFACE_NAME).withArguments(interactive).storeResultsTo(result);
return result;
}
std::string GetHardwareSerial()
{
std::string result;
proxy_.callMethod("GetHardwareSerial").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetHardwareSerial").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string Describe()
{
std::string result;
proxy_.callMethod("Describe").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("Describe").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
public:
std::string Hostname()
{
return proxy_.getProperty("Hostname").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Hostname").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string StaticHostname()
{
return proxy_.getProperty("StaticHostname").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("StaticHostname").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string PrettyHostname()
{
return proxy_.getProperty("PrettyHostname").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PrettyHostname").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string DefaultHostname()
{
return proxy_.getProperty("DefaultHostname").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("DefaultHostname").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HostnameSource()
{
return proxy_.getProperty("HostnameSource").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HostnameSource").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string IconName()
{
return proxy_.getProperty("IconName").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IconName").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Chassis()
{
return proxy_.getProperty("Chassis").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Chassis").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Deployment()
{
return proxy_.getProperty("Deployment").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Deployment").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Location()
{
return proxy_.getProperty("Location").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Location").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string KernelName()
{
return proxy_.getProperty("KernelName").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KernelName").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string KernelRelease()
{
return proxy_.getProperty("KernelRelease").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KernelRelease").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string KernelVersion()
{
return proxy_.getProperty("KernelVersion").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KernelVersion").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string OperatingSystemPrettyName()
{
return proxy_.getProperty("OperatingSystemPrettyName").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("OperatingSystemPrettyName").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string OperatingSystemCPEName()
{
return proxy_.getProperty("OperatingSystemCPEName").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("OperatingSystemCPEName").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t OperatingSystemSupportEnd()
{
return proxy_.getProperty("OperatingSystemSupportEnd").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("OperatingSystemSupportEnd").onInterface(INTERFACE_NAME).get<uint64_t>();
}
std::string HomeURL()
{
return proxy_.getProperty("HomeURL").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HomeURL").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HardwareVendor()
{
return proxy_.getProperty("HardwareVendor").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HardwareVendor").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HardwareModel()
{
return proxy_.getProperty("HardwareModel").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HardwareModel").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string FirmwareVersion()
{
return proxy_.getProperty("FirmwareVersion").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("FirmwareVersion").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string FirmwareVendor()
{
return proxy_.getProperty("FirmwareVendor").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("FirmwareVendor").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t FirmwareDate()
{
return proxy_.getProperty("FirmwareDate").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("FirmwareDate").onInterface(INTERFACE_NAME).get<uint64_t>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/logcontrol/logcontrol_server.h
+17 -7
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__org_freedesktop_logcontrol_server_glue_h__adaptor__H__
#define __sdbuscpp__org_freedesktop_logcontrol_server_glue_h__adaptor__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_logcontrol_logcontrol_server_v2_h__adaptor__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_logcontrol_logcontrol_server_v2_h__adaptor__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,15 +20,25 @@ public:
protected:
LogControl1_adaptor(sdbus::IObject& object)
: object_(object)
: m_object(object)
{
object_.registerProperty("LogLevel").onInterface(INTERFACE_NAME).withGetter([this](){ return this->LogLevel(); }).withSetter([this](const std::string& value){ this->LogLevel(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL).markAsPrivileged();
object_.registerProperty("LogTarget").onInterface(INTERFACE_NAME).withGetter([this](){ return this->LogTarget(); }).withSetter([this](const std::string& value){ this->LogTarget(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL).markAsPrivileged();
object_.registerProperty("SyslogIdentifier").onInterface(INTERFACE_NAME).withGetter([this](){ return this->SyslogIdentifier(); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
}
LogControl1_adaptor(const LogControl1_adaptor&) = delete;
LogControl1_adaptor& operator=(const LogControl1_adaptor&) = delete;
LogControl1_adaptor(LogControl1_adaptor&&) = delete;
LogControl1_adaptor& operator=(LogControl1_adaptor&&) = delete;
~LogControl1_adaptor() = default;
void registerAdaptor()
{
m_object.addVTable( sdbus::registerProperty("LogLevel").withGetter([this](){ return this->LogLevel(); }).withSetter([this](const std::string& value){ this->LogLevel(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL).markAsPrivileged()
, sdbus::registerProperty("LogTarget").withGetter([this](){ return this->LogTarget(); }).withSetter([this](const std::string& value){ this->LogTarget(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL).markAsPrivileged()
, sdbus::registerProperty("SyslogIdentifier").withGetter([this](){ return this->SyslogIdentifier(); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL)
).forInterface(INTERFACE_NAME);
}
private:
virtual std::string LogLevel() = 0;
virtual void LogLevel(const std::string& value) = 0;
@@ -37,7 +47,7 @@ private:
virtual std::string SyslogIdentifier() = 0;
private:
sdbus::IObject& object_;
sdbus::IObject& m_object;
};
}} // namespaces
internal/platform/implementation/linux/generated/dbus/login/login_manager_client.h
+127 -118
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__login_manager_client_glue_h__proxy__H__
#define __sdbuscpp__login_manager_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_login_login_manager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_login_login_manager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -21,20 +21,29 @@ public:
protected:
Manager_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("SessionNew").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionNew(session_id, object_path); });
proxy_.uponSignal("SessionRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionRemoved(session_id, object_path); });
proxy_.uponSignal("UserNew").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserNew(uid, object_path); });
proxy_.uponSignal("UserRemoved").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserRemoved(uid, object_path); });
proxy_.uponSignal("SeatNew").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatNew(seat_id, object_path); });
proxy_.uponSignal("SeatRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatRemoved(seat_id, object_path); });
proxy_.uponSignal("PrepareForShutdown").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForShutdown(start); });
proxy_.uponSignal("PrepareForSleep").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForSleep(start); });
}
Manager_proxy(const Manager_proxy&) = delete;
Manager_proxy& operator=(const Manager_proxy&) = delete;
Manager_proxy(Manager_proxy&&) = delete;
Manager_proxy& operator=(Manager_proxy&&) = delete;
~Manager_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("SessionNew").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionNew(session_id, object_path); });
m_proxy.uponSignal("SessionRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionRemoved(session_id, object_path); });
m_proxy.uponSignal("UserNew").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserNew(uid, object_path); });
m_proxy.uponSignal("UserRemoved").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserRemoved(uid, object_path); });
m_proxy.uponSignal("SeatNew").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatNew(seat_id, object_path); });
m_proxy.uponSignal("SeatRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatRemoved(seat_id, object_path); });
m_proxy.uponSignal("PrepareForShutdown").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForShutdown(start); });
m_proxy.uponSignal("PrepareForSleep").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForSleep(start); });
}
virtual void onSessionNew(const std::string& session_id, const sdbus::ObjectPath& object_path) = 0;
virtual void onSessionRemoved(const std::string& session_id, const sdbus::ObjectPath& object_path) = 0;
virtual void onUserNew(const uint32_t& uid, const sdbus::ObjectPath& object_path) = 0;
@@ -48,582 +57,582 @@ public:
sdbus::ObjectPath GetSession(const std::string& session_id)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetSession").onInterface(INTERFACE_NAME).withArguments(session_id).storeResultsTo(result);
m_proxy.callMethod("GetSession").onInterface(INTERFACE_NAME).withArguments(session_id).storeResultsTo(result);
return result;
}
sdbus::ObjectPath GetSessionByPID(const uint32_t& pid)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetSessionByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result);
m_proxy.callMethod("GetSessionByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result);
return result;
}
sdbus::ObjectPath GetUser(const uint32_t& uid)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetUser").onInterface(INTERFACE_NAME).withArguments(uid).storeResultsTo(result);
m_proxy.callMethod("GetUser").onInterface(INTERFACE_NAME).withArguments(uid).storeResultsTo(result);
return result;
}
sdbus::ObjectPath GetUserByPID(const uint32_t& pid)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetUserByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result);
m_proxy.callMethod("GetUserByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result);
return result;
}
sdbus::ObjectPath GetSeat(const std::string& seat_id)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetSeat").onInterface(INTERFACE_NAME).withArguments(seat_id).storeResultsTo(result);
m_proxy.callMethod("GetSeat").onInterface(INTERFACE_NAME).withArguments(seat_id).storeResultsTo(result);
return result;
}
std::vector<sdbus::Struct<std::string, uint32_t, std::string, std::string, sdbus::ObjectPath>> ListSessions()
{
std::vector<sdbus::Struct<std::string, uint32_t, std::string, std::string, sdbus::ObjectPath>> result;
proxy_.callMethod("ListSessions").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("ListSessions").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::vector<sdbus::Struct<uint32_t, std::string, sdbus::ObjectPath>> ListUsers()
{
std::vector<sdbus::Struct<uint32_t, std::string, sdbus::ObjectPath>> result;
proxy_.callMethod("ListUsers").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("ListUsers").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::vector<sdbus::Struct<std::string, sdbus::ObjectPath>> ListSeats()
{
std::vector<sdbus::Struct<std::string, sdbus::ObjectPath>> result;
proxy_.callMethod("ListSeats").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("ListSeats").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::vector<sdbus::Struct<std::string, std::string, std::string, std::string, uint32_t, uint32_t>> ListInhibitors()
{
std::vector<sdbus::Struct<std::string, std::string, std::string, std::string, uint32_t, uint32_t>> result;
proxy_.callMethod("ListInhibitors").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("ListInhibitors").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::tuple<std::string, sdbus::ObjectPath, std::string, sdbus::UnixFd, uint32_t, std::string, uint32_t, bool> CreateSession(const uint32_t& uid, const uint32_t& pid, const std::string& service, const std::string& type, const std::string& class_, const std::string& desktop, const std::string& seat_id, const uint32_t& vtnr, const std::string& tty, const std::string& display, const bool& remote, const std::string& remote_user, const std::string& remote_host, const std::vector<sdbus::Struct<std::string, sdbus::Variant>>& properties)
{
std::tuple<std::string, sdbus::ObjectPath, std::string, sdbus::UnixFd, uint32_t, std::string, uint32_t, bool> result;
proxy_.callMethod("CreateSession").onInterface(INTERFACE_NAME).withArguments(uid, pid, service, type, class_, desktop, seat_id, vtnr, tty, display, remote, remote_user, remote_host, properties).storeResultsTo(result);
m_proxy.callMethod("CreateSession").onInterface(INTERFACE_NAME).withArguments(uid, pid, service, type, class_, desktop, seat_id, vtnr, tty, display, remote, remote_user, remote_host, properties).storeResultsTo(result);
return result;
}
void ReleaseSession(const std::string& session_id)
{
proxy_.callMethod("ReleaseSession").onInterface(INTERFACE_NAME).withArguments(session_id);
m_proxy.callMethod("ReleaseSession").onInterface(INTERFACE_NAME).withArguments(session_id);
}
void ActivateSession(const std::string& session_id)
{
proxy_.callMethod("ActivateSession").onInterface(INTERFACE_NAME).withArguments(session_id);
m_proxy.callMethod("ActivateSession").onInterface(INTERFACE_NAME).withArguments(session_id);
}
void ActivateSessionOnSeat(const std::string& session_id, const std::string& seat_id)
{
proxy_.callMethod("ActivateSessionOnSeat").onInterface(INTERFACE_NAME).withArguments(session_id, seat_id);
m_proxy.callMethod("ActivateSessionOnSeat").onInterface(INTERFACE_NAME).withArguments(session_id, seat_id);
}
void LockSession(const std::string& session_id)
{
proxy_.callMethod("LockSession").onInterface(INTERFACE_NAME).withArguments(session_id);
m_proxy.callMethod("LockSession").onInterface(INTERFACE_NAME).withArguments(session_id);
}
void UnlockSession(const std::string& session_id)
{
proxy_.callMethod("UnlockSession").onInterface(INTERFACE_NAME).withArguments(session_id);
m_proxy.callMethod("UnlockSession").onInterface(INTERFACE_NAME).withArguments(session_id);
}
void LockSessions()
{
proxy_.callMethod("LockSessions").onInterface(INTERFACE_NAME);
m_proxy.callMethod("LockSessions").onInterface(INTERFACE_NAME);
}
void UnlockSessions()
{
proxy_.callMethod("UnlockSessions").onInterface(INTERFACE_NAME);
m_proxy.callMethod("UnlockSessions").onInterface(INTERFACE_NAME);
}
void KillSession(const std::string& session_id, const std::string& who, const int32_t& signal_number)
{
proxy_.callMethod("KillSession").onInterface(INTERFACE_NAME).withArguments(session_id, who, signal_number);
m_proxy.callMethod("KillSession").onInterface(INTERFACE_NAME).withArguments(session_id, who, signal_number);
}
void KillUser(const uint32_t& uid, const int32_t& signal_number)
{
proxy_.callMethod("KillUser").onInterface(INTERFACE_NAME).withArguments(uid, signal_number);
m_proxy.callMethod("KillUser").onInterface(INTERFACE_NAME).withArguments(uid, signal_number);
}
void TerminateSession(const std::string& session_id)
{
proxy_.callMethod("TerminateSession").onInterface(INTERFACE_NAME).withArguments(session_id);
m_proxy.callMethod("TerminateSession").onInterface(INTERFACE_NAME).withArguments(session_id);
}
void TerminateUser(const uint32_t& uid)
{
proxy_.callMethod("TerminateUser").onInterface(INTERFACE_NAME).withArguments(uid);
m_proxy.callMethod("TerminateUser").onInterface(INTERFACE_NAME).withArguments(uid);
}
void TerminateSeat(const std::string& seat_id)
{
proxy_.callMethod("TerminateSeat").onInterface(INTERFACE_NAME).withArguments(seat_id);
m_proxy.callMethod("TerminateSeat").onInterface(INTERFACE_NAME).withArguments(seat_id);
}
void SetUserLinger(const uint32_t& uid, const bool& enable, const bool& interactive)
{
proxy_.callMethod("SetUserLinger").onInterface(INTERFACE_NAME).withArguments(uid, enable, interactive);
m_proxy.callMethod("SetUserLinger").onInterface(INTERFACE_NAME).withArguments(uid, enable, interactive);
}
void AttachDevice(const std::string& seat_id, const std::string& sysfs_path, const bool& interactive)
{
proxy_.callMethod("AttachDevice").onInterface(INTERFACE_NAME).withArguments(seat_id, sysfs_path, interactive);
m_proxy.callMethod("AttachDevice").onInterface(INTERFACE_NAME).withArguments(seat_id, sysfs_path, interactive);
}
void FlushDevices(const bool& interactive)
{
proxy_.callMethod("FlushDevices").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("FlushDevices").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void PowerOff(const bool& interactive)
{
proxy_.callMethod("PowerOff").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("PowerOff").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void PowerOffWithFlags(const uint64_t& flags)
{
proxy_.callMethod("PowerOffWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("PowerOffWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void Reboot(const bool& interactive)
{
proxy_.callMethod("Reboot").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("Reboot").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void RebootWithFlags(const uint64_t& flags)
{
proxy_.callMethod("RebootWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("RebootWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void Halt(const bool& interactive)
{
proxy_.callMethod("Halt").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("Halt").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void HaltWithFlags(const uint64_t& flags)
{
proxy_.callMethod("HaltWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("HaltWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void Suspend(const bool& interactive)
{
proxy_.callMethod("Suspend").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("Suspend").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void SuspendWithFlags(const uint64_t& flags)
{
proxy_.callMethod("SuspendWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("SuspendWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void Hibernate(const bool& interactive)
{
proxy_.callMethod("Hibernate").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("Hibernate").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void HibernateWithFlags(const uint64_t& flags)
{
proxy_.callMethod("HibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("HibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void HybridSleep(const bool& interactive)
{
proxy_.callMethod("HybridSleep").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("HybridSleep").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void HybridSleepWithFlags(const uint64_t& flags)
{
proxy_.callMethod("HybridSleepWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("HybridSleepWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
void SuspendThenHibernate(const bool& interactive)
{
proxy_.callMethod("SuspendThenHibernate").onInterface(INTERFACE_NAME).withArguments(interactive);
m_proxy.callMethod("SuspendThenHibernate").onInterface(INTERFACE_NAME).withArguments(interactive);
}
void SuspendThenHibernateWithFlags(const uint64_t& flags)
{
proxy_.callMethod("SuspendThenHibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("SuspendThenHibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags);
}
std::string CanPowerOff()
{
std::string result;
proxy_.callMethod("CanPowerOff").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanPowerOff").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanReboot()
{
std::string result;
proxy_.callMethod("CanReboot").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanReboot").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanHalt()
{
std::string result;
proxy_.callMethod("CanHalt").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanHalt").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanSuspend()
{
std::string result;
proxy_.callMethod("CanSuspend").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanSuspend").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanHibernate()
{
std::string result;
proxy_.callMethod("CanHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanHybridSleep()
{
std::string result;
proxy_.callMethod("CanHybridSleep").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanHybridSleep").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::string CanSuspendThenHibernate()
{
std::string result;
proxy_.callMethod("CanSuspendThenHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanSuspendThenHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void ScheduleShutdown(const std::string& type, const uint64_t& usec)
{
proxy_.callMethod("ScheduleShutdown").onInterface(INTERFACE_NAME).withArguments(type, usec);
m_proxy.callMethod("ScheduleShutdown").onInterface(INTERFACE_NAME).withArguments(type, usec);
}
bool CancelScheduledShutdown()
{
bool result;
proxy_.callMethod("CancelScheduledShutdown").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CancelScheduledShutdown").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
sdbus::UnixFd Inhibit(const std::string& what, const std::string& who, const std::string& why, const std::string& mode)
{
sdbus::UnixFd result;
proxy_.callMethod("Inhibit").onInterface(INTERFACE_NAME).withArguments(what, who, why, mode).storeResultsTo(result);
m_proxy.callMethod("Inhibit").onInterface(INTERFACE_NAME).withArguments(what, who, why, mode).storeResultsTo(result);
return result;
}
std::string CanRebootParameter()
{
std::string result;
proxy_.callMethod("CanRebootParameter").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanRebootParameter").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetRebootParameter(const std::string& parameter)
{
proxy_.callMethod("SetRebootParameter").onInterface(INTERFACE_NAME).withArguments(parameter);
m_proxy.callMethod("SetRebootParameter").onInterface(INTERFACE_NAME).withArguments(parameter);
}
std::string CanRebootToFirmwareSetup()
{
std::string result;
proxy_.callMethod("CanRebootToFirmwareSetup").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanRebootToFirmwareSetup").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetRebootToFirmwareSetup(const bool& enable)
{
proxy_.callMethod("SetRebootToFirmwareSetup").onInterface(INTERFACE_NAME).withArguments(enable);
m_proxy.callMethod("SetRebootToFirmwareSetup").onInterface(INTERFACE_NAME).withArguments(enable);
}
std::string CanRebootToBootLoaderMenu()
{
std::string result;
proxy_.callMethod("CanRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetRebootToBootLoaderMenu(const uint64_t& timeout)
{
proxy_.callMethod("SetRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).withArguments(timeout);
m_proxy.callMethod("SetRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).withArguments(timeout);
}
std::string CanRebootToBootLoaderEntry()
{
std::string result;
proxy_.callMethod("CanRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CanRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetRebootToBootLoaderEntry(const std::string& boot_loader_entry)
{
proxy_.callMethod("SetRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).withArguments(boot_loader_entry);
m_proxy.callMethod("SetRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).withArguments(boot_loader_entry);
}
void SetWallMessage(const std::string& wall_message, const bool& enable)
{
proxy_.callMethod("SetWallMessage").onInterface(INTERFACE_NAME).withArguments(wall_message, enable);
m_proxy.callMethod("SetWallMessage").onInterface(INTERFACE_NAME).withArguments(wall_message, enable);
}
public:
bool EnableWallMessages()
{
return proxy_.getProperty("EnableWallMessages").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("EnableWallMessages").onInterface(INTERFACE_NAME).get<bool>();
}
void EnableWallMessages(const bool& value)
{
proxy_.setProperty("EnableWallMessages").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("EnableWallMessages").onInterface(INTERFACE_NAME).toValue(value);
}
std::string WallMessage()
{
return proxy_.getProperty("WallMessage").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WallMessage").onInterface(INTERFACE_NAME).get<std::string>();
}
void WallMessage(const std::string& value)
{
proxy_.setProperty("WallMessage").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("WallMessage").onInterface(INTERFACE_NAME).toValue(value);
}
uint32_t NAutoVTs()
{
return proxy_.getProperty("NAutoVTs").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NAutoVTs").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::vector<std::string> KillOnlyUsers()
{
return proxy_.getProperty("KillOnlyUsers").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KillOnlyUsers").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> KillExcludeUsers()
{
return proxy_.getProperty("KillExcludeUsers").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KillExcludeUsers").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
bool KillUserProcesses()
{
return proxy_.getProperty("KillUserProcesses").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("KillUserProcesses").onInterface(INTERFACE_NAME).get<bool>();
}
std::string RebootParameter()
{
return proxy_.getProperty("RebootParameter").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RebootParameter").onInterface(INTERFACE_NAME).get<std::string>();
}
bool RebootToFirmwareSetup()
{
return proxy_.getProperty("RebootToFirmwareSetup").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RebootToFirmwareSetup").onInterface(INTERFACE_NAME).get<bool>();
}
uint64_t RebootToBootLoaderMenu()
{
return proxy_.getProperty("RebootToBootLoaderMenu").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RebootToBootLoaderMenu").onInterface(INTERFACE_NAME).get<uint64_t>();
}
std::string RebootToBootLoaderEntry()
{
return proxy_.getProperty("RebootToBootLoaderEntry").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RebootToBootLoaderEntry").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<std::string> BootLoaderEntries()
{
return proxy_.getProperty("BootLoaderEntries").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("BootLoaderEntries").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
bool IdleHint()
{
return proxy_.getProperty("IdleHint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleHint").onInterface(INTERFACE_NAME).get<bool>();
}
uint64_t IdleSinceHint()
{
return proxy_.getProperty("IdleSinceHint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleSinceHint").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t IdleSinceHintMonotonic()
{
return proxy_.getProperty("IdleSinceHintMonotonic").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleSinceHintMonotonic").onInterface(INTERFACE_NAME).get<uint64_t>();
}
std::string BlockInhibited()
{
return proxy_.getProperty("BlockInhibited").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("BlockInhibited").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string DelayInhibited()
{
return proxy_.getProperty("DelayInhibited").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("DelayInhibited").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t InhibitDelayMaxUSec()
{
return proxy_.getProperty("InhibitDelayMaxUSec").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("InhibitDelayMaxUSec").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t UserStopDelayUSec()
{
return proxy_.getProperty("UserStopDelayUSec").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("UserStopDelayUSec").onInterface(INTERFACE_NAME).get<uint64_t>();
}
std::string HandlePowerKey()
{
return proxy_.getProperty("HandlePowerKey").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandlePowerKey").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandlePowerKeyLongPress()
{
return proxy_.getProperty("HandlePowerKeyLongPress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandlePowerKeyLongPress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleRebootKey()
{
return proxy_.getProperty("HandleRebootKey").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleRebootKey").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleRebootKeyLongPress()
{
return proxy_.getProperty("HandleRebootKeyLongPress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleRebootKeyLongPress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleSuspendKey()
{
return proxy_.getProperty("HandleSuspendKey").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleSuspendKey").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleSuspendKeyLongPress()
{
return proxy_.getProperty("HandleSuspendKeyLongPress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleSuspendKeyLongPress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleHibernateKey()
{
return proxy_.getProperty("HandleHibernateKey").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleHibernateKey").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleHibernateKeyLongPress()
{
return proxy_.getProperty("HandleHibernateKeyLongPress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleHibernateKeyLongPress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleLidSwitch()
{
return proxy_.getProperty("HandleLidSwitch").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleLidSwitch").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleLidSwitchExternalPower()
{
return proxy_.getProperty("HandleLidSwitchExternalPower").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleLidSwitchExternalPower").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string HandleLidSwitchDocked()
{
return proxy_.getProperty("HandleLidSwitchDocked").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HandleLidSwitchDocked").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t HoldoffTimeoutUSec()
{
return proxy_.getProperty("HoldoffTimeoutUSec").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HoldoffTimeoutUSec").onInterface(INTERFACE_NAME).get<uint64_t>();
}
std::string IdleAction()
{
return proxy_.getProperty("IdleAction").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleAction").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t IdleActionUSec()
{
return proxy_.getProperty("IdleActionUSec").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleActionUSec").onInterface(INTERFACE_NAME).get<uint64_t>();
}
bool PreparingForShutdown()
{
return proxy_.getProperty("PreparingForShutdown").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PreparingForShutdown").onInterface(INTERFACE_NAME).get<bool>();
}
bool PreparingForSleep()
{
return proxy_.getProperty("PreparingForSleep").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PreparingForSleep").onInterface(INTERFACE_NAME).get<bool>();
}
sdbus::Struct<std::string, uint64_t> ScheduledShutdown()
{
return proxy_.getProperty("ScheduledShutdown").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ScheduledShutdown").onInterface(INTERFACE_NAME).get<sdbus::Struct<std::string, uint64_t>>();
}
bool Docked()
{
return proxy_.getProperty("Docked").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Docked").onInterface(INTERFACE_NAME).get<bool>();
}
bool LidClosed()
{
return proxy_.getProperty("LidClosed").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("LidClosed").onInterface(INTERFACE_NAME).get<bool>();
}
bool OnExternalPower()
{
return proxy_.getProperty("OnExternalPower").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("OnExternalPower").onInterface(INTERFACE_NAME).get<bool>();
}
bool RemoveIPC()
{
return proxy_.getProperty("RemoveIPC").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RemoveIPC").onInterface(INTERFACE_NAME).get<bool>();
}
uint64_t RuntimeDirectorySize()
{
return proxy_.getProperty("RuntimeDirectorySize").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RuntimeDirectorySize").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t RuntimeDirectoryInodesMax()
{
return proxy_.getProperty("RuntimeDirectoryInodesMax").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RuntimeDirectoryInodesMax").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t InhibitorsMax()
{
return proxy_.getProperty("InhibitorsMax").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("InhibitorsMax").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t NCurrentInhibitors()
{
return proxy_.getProperty("NCurrentInhibitors").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NCurrentInhibitors").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t SessionsMax()
{
return proxy_.getProperty("SessionsMax").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SessionsMax").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t NCurrentSessions()
{
return proxy_.getProperty("NCurrentSessions").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NCurrentSessions").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t StopIdleSessionUSec()
{
return proxy_.getProperty("StopIdleSessionUSec").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("StopIdleSessionUSec").onInterface(INTERFACE_NAME).get<uint64_t>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}} // namespaces
internal/platform/implementation/linux/generated/dbus/login/login_session_client.h
+58 -49
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__login_session_client_glue_h__proxy__H__
#define __sdbuscpp__login_session_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_login_login_session_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_login_login_session_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -21,16 +21,25 @@ public:
protected:
Session_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("PauseDevice").onInterface(INTERFACE_NAME).call([this](const uint32_t& major, const uint32_t& minor, const std::string& type){ this->onPauseDevice(major, minor, type); });
proxy_.uponSignal("ResumeDevice").onInterface(INTERFACE_NAME).call([this](const uint32_t& major, const uint32_t& minor, const sdbus::UnixFd& fd){ this->onResumeDevice(major, minor, fd); });
proxy_.uponSignal("Lock").onInterface(INTERFACE_NAME).call([this](){ this->onLock(); });
proxy_.uponSignal("Unlock").onInterface(INTERFACE_NAME).call([this](){ this->onUnlock(); });
}
Session_proxy(const Session_proxy&) = delete;
Session_proxy& operator=(const Session_proxy&) = delete;
Session_proxy(Session_proxy&&) = delete;
Session_proxy& operator=(Session_proxy&&) = delete;
~Session_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("PauseDevice").onInterface(INTERFACE_NAME).call([this](const uint32_t& major, const uint32_t& minor, const std::string& type){ this->onPauseDevice(major, minor, type); });
m_proxy.uponSignal("ResumeDevice").onInterface(INTERFACE_NAME).call([this](const uint32_t& major, const uint32_t& minor, const sdbus::UnixFd& fd){ this->onResumeDevice(major, minor, fd); });
m_proxy.uponSignal("Lock").onInterface(INTERFACE_NAME).call([this](){ this->onLock(); });
m_proxy.uponSignal("Unlock").onInterface(INTERFACE_NAME).call([this](){ this->onUnlock(); });
}
virtual void onPauseDevice(const uint32_t& major, const uint32_t& minor, const std::string& type) = 0;
virtual void onResumeDevice(const uint32_t& major, const uint32_t& minor, const sdbus::UnixFd& fd) = 0;
virtual void onLock() = 0;
@@ -39,214 +48,214 @@ protected:
public:
void Terminate()
{
proxy_.callMethod("Terminate").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Terminate").onInterface(INTERFACE_NAME);
}
void Activate()
{
proxy_.callMethod("Activate").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Activate").onInterface(INTERFACE_NAME);
}
void Lock()
{
proxy_.callMethod("Lock").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Lock").onInterface(INTERFACE_NAME);
}
void Unlock()
{
proxy_.callMethod("Unlock").onInterface(INTERFACE_NAME);
m_proxy.callMethod("Unlock").onInterface(INTERFACE_NAME);
}
void SetIdleHint(const bool& idle)
{
proxy_.callMethod("SetIdleHint").onInterface(INTERFACE_NAME).withArguments(idle);
m_proxy.callMethod("SetIdleHint").onInterface(INTERFACE_NAME).withArguments(idle);
}
void SetLockedHint(const bool& locked)
{
proxy_.callMethod("SetLockedHint").onInterface(INTERFACE_NAME).withArguments(locked);
m_proxy.callMethod("SetLockedHint").onInterface(INTERFACE_NAME).withArguments(locked);
}
void Kill(const std::string& who, const int32_t& signal_number)
{
proxy_.callMethod("Kill").onInterface(INTERFACE_NAME).withArguments(who, signal_number);
m_proxy.callMethod("Kill").onInterface(INTERFACE_NAME).withArguments(who, signal_number);
}
void TakeControl(const bool& force)
{
proxy_.callMethod("TakeControl").onInterface(INTERFACE_NAME).withArguments(force);
m_proxy.callMethod("TakeControl").onInterface(INTERFACE_NAME).withArguments(force);
}
void ReleaseControl()
{
proxy_.callMethod("ReleaseControl").onInterface(INTERFACE_NAME);
m_proxy.callMethod("ReleaseControl").onInterface(INTERFACE_NAME);
}
void SetType(const std::string& type)
{
proxy_.callMethod("SetType").onInterface(INTERFACE_NAME).withArguments(type);
m_proxy.callMethod("SetType").onInterface(INTERFACE_NAME).withArguments(type);
}
void SetDisplay(const std::string& display)
{
proxy_.callMethod("SetDisplay").onInterface(INTERFACE_NAME).withArguments(display);
m_proxy.callMethod("SetDisplay").onInterface(INTERFACE_NAME).withArguments(display);
}
void SetTTY(const sdbus::UnixFd& tty_fd)
{
proxy_.callMethod("SetTTY").onInterface(INTERFACE_NAME).withArguments(tty_fd);
m_proxy.callMethod("SetTTY").onInterface(INTERFACE_NAME).withArguments(tty_fd);
}
std::tuple<sdbus::UnixFd, bool> TakeDevice(const uint32_t& major, const uint32_t& minor)
{
std::tuple<sdbus::UnixFd, bool> result;
proxy_.callMethod("TakeDevice").onInterface(INTERFACE_NAME).withArguments(major, minor).storeResultsTo(result);
m_proxy.callMethod("TakeDevice").onInterface(INTERFACE_NAME).withArguments(major, minor).storeResultsTo(result);
return result;
}
void ReleaseDevice(const uint32_t& major, const uint32_t& minor)
{
proxy_.callMethod("ReleaseDevice").onInterface(INTERFACE_NAME).withArguments(major, minor);
m_proxy.callMethod("ReleaseDevice").onInterface(INTERFACE_NAME).withArguments(major, minor);
}
void PauseDeviceComplete(const uint32_t& major, const uint32_t& minor)
{
proxy_.callMethod("PauseDeviceComplete").onInterface(INTERFACE_NAME).withArguments(major, minor);
m_proxy.callMethod("PauseDeviceComplete").onInterface(INTERFACE_NAME).withArguments(major, minor);
}
void SetBrightness(const std::string& subsystem, const std::string& name, const uint32_t& brightness)
{
proxy_.callMethod("SetBrightness").onInterface(INTERFACE_NAME).withArguments(subsystem, name, brightness);
m_proxy.callMethod("SetBrightness").onInterface(INTERFACE_NAME).withArguments(subsystem, name, brightness);
}
public:
std::string Id()
{
return proxy_.getProperty("Id").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Id").onInterface(INTERFACE_NAME).get<std::string>();
}
sdbus::Struct<uint32_t, sdbus::ObjectPath> User()
{
return proxy_.getProperty("User").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("User").onInterface(INTERFACE_NAME).get<sdbus::Struct<uint32_t, sdbus::ObjectPath>>();
}
std::string Name()
{
return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Name").onInterface(INTERFACE_NAME).get<std::string>();
}
uint64_t Timestamp()
{
return proxy_.getProperty("Timestamp").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Timestamp").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t TimestampMonotonic()
{
return proxy_.getProperty("TimestampMonotonic").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("TimestampMonotonic").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint32_t VTNr()
{
return proxy_.getProperty("VTNr").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("VTNr").onInterface(INTERFACE_NAME).get<uint32_t>();
}
sdbus::Struct<std::string, sdbus::ObjectPath> Seat()
{
return proxy_.getProperty("Seat").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Seat").onInterface(INTERFACE_NAME).get<sdbus::Struct<std::string, sdbus::ObjectPath>>();
}
std::string TTY()
{
return proxy_.getProperty("TTY").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("TTY").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Display()
{
return proxy_.getProperty("Display").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Display").onInterface(INTERFACE_NAME).get<std::string>();
}
bool Remote()
{
return proxy_.getProperty("Remote").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Remote").onInterface(INTERFACE_NAME).get<bool>();
}
std::string RemoteHost()
{
return proxy_.getProperty("RemoteHost").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RemoteHost").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string RemoteUser()
{
return proxy_.getProperty("RemoteUser").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RemoteUser").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Service()
{
return proxy_.getProperty("Service").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Service").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Desktop()
{
return proxy_.getProperty("Desktop").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Desktop").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Scope()
{
return proxy_.getProperty("Scope").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Scope").onInterface(INTERFACE_NAME).get<std::string>();
}
uint32_t Leader()
{
return proxy_.getProperty("Leader").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Leader").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t Audit()
{
return proxy_.getProperty("Audit").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Audit").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::string Type()
{
return proxy_.getProperty("Type").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Type").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Class()
{
return proxy_.getProperty("Class").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Class").onInterface(INTERFACE_NAME).get<std::string>();
}
bool Active()
{
return proxy_.getProperty("Active").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Active").onInterface(INTERFACE_NAME).get<bool>();
}
std::string State()
{
return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("State").onInterface(INTERFACE_NAME).get<std::string>();
}
bool IdleHint()
{
return proxy_.getProperty("IdleHint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleHint").onInterface(INTERFACE_NAME).get<bool>();
}
uint64_t IdleSinceHint()
{
return proxy_.getProperty("IdleSinceHint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleSinceHint").onInterface(INTERFACE_NAME).get<uint64_t>();
}
uint64_t IdleSinceHintMonotonic()
{
return proxy_.getProperty("IdleSinceHintMonotonic").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("IdleSinceHintMonotonic").onInterface(INTERFACE_NAME).get<uint64_t>();
}
bool LockedHint()
{
return proxy_.getProperty("LockedHint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("LockedHint").onInterface(INTERFACE_NAME).get<bool>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/access_point_client.h
+23 -14
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_accesspoint_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_accesspoint_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_access_point_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_access_point_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -21,65 +21,74 @@ public:
protected:
AccessPoint_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
AccessPoint_proxy(const AccessPoint_proxy&) = delete;
AccessPoint_proxy& operator=(const AccessPoint_proxy&) = delete;
AccessPoint_proxy(AccessPoint_proxy&&) = delete;
AccessPoint_proxy& operator=(AccessPoint_proxy&&) = delete;
~AccessPoint_proxy() = default;
void registerProxy()
{
}
public:
uint32_t Flags()
{
return proxy_.getProperty("Flags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Flags").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t WpaFlags()
{
return proxy_.getProperty("WpaFlags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WpaFlags").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t RsnFlags()
{
return proxy_.getProperty("RsnFlags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RsnFlags").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::vector<uint8_t> Ssid()
{
return proxy_.getProperty("Ssid").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Ssid").onInterface(INTERFACE_NAME).get<std::vector<uint8_t>>();
}
uint32_t Frequency()
{
return proxy_.getProperty("Frequency").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Frequency").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::string HwAddress()
{
return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HwAddress").onInterface(INTERFACE_NAME).get<std::string>();
}
uint32_t Mode()
{
return proxy_.getProperty("Mode").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Mode").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t MaxBitrate()
{
return proxy_.getProperty("MaxBitrate").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("MaxBitrate").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint8_t Strength()
{
return proxy_.getProperty("Strength").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Strength").onInterface(INTERFACE_NAME).get<uint8_t>();
}
int32_t LastSeen()
{
return proxy_.getProperty("LastSeen").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("LastSeen").onInterface(INTERFACE_NAME).get<int32_t>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/connection_active_client.h
+31 -22
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_connection_active_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_connection_active_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_connection_active_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_connection_active_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -22,103 +22,112 @@ public:
protected:
Active_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state, const uint32_t& reason){ this->onStateChanged(state, reason); });
}
Active_proxy(const Active_proxy&) = delete;
Active_proxy& operator=(const Active_proxy&) = delete;
Active_proxy(Active_proxy&&) = delete;
Active_proxy& operator=(Active_proxy&&) = delete;
~Active_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state, const uint32_t& reason){ this->onStateChanged(state, reason); });
}
virtual void onStateChanged(const uint32_t& state, const uint32_t& reason) = 0;
public:
sdbus::ObjectPath Connection()
{
return proxy_.getProperty("Connection").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Connection").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
sdbus::ObjectPath SpecificObject()
{
return proxy_.getProperty("SpecificObject").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("SpecificObject").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
std::string Id()
{
return proxy_.getProperty("Id").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Id").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Uuid()
{
return proxy_.getProperty("Uuid").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Uuid").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string Type()
{
return proxy_.getProperty("Type").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Type").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<sdbus::ObjectPath> Devices()
{
return proxy_.getProperty("Devices").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Devices").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
uint32_t State()
{
return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("State").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t StateFlags()
{
return proxy_.getProperty("StateFlags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("StateFlags").onInterface(INTERFACE_NAME).get<uint32_t>();
}
bool Default()
{
return proxy_.getProperty("Default").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Default").onInterface(INTERFACE_NAME).get<bool>();
}
sdbus::ObjectPath Ip4Config()
{
return proxy_.getProperty("Ip4Config").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Ip4Config").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
sdbus::ObjectPath Dhcp4Config()
{
return proxy_.getProperty("Dhcp4Config").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Dhcp4Config").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
bool Default6()
{
return proxy_.getProperty("Default6").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Default6").onInterface(INTERFACE_NAME).get<bool>();
}
sdbus::ObjectPath Ip6Config()
{
return proxy_.getProperty("Ip6Config").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Ip6Config").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
sdbus::ObjectPath Dhcp6Config()
{
return proxy_.getProperty("Dhcp6Config").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Dhcp6Config").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
bool Vpn()
{
return proxy_.getProperty("Vpn").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Vpn").onInterface(INTERFACE_NAME).get<bool>();
}
sdbus::ObjectPath Controller()
{
return proxy_.getProperty("Controller").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Controller").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
sdbus::ObjectPath Master()
{
return proxy_.getProperty("Master").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Master").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/device_wifip2p_client.h
+19 -10
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_device_wifip2p_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_device_wifip2p_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_device_wifip2p_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_device_wifip2p_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -22,41 +22,50 @@ public:
protected:
WifiP2P_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("PeerAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerAdded(peer); });
proxy_.uponSignal("PeerRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerRemoved(peer); });
}
WifiP2P_proxy(const WifiP2P_proxy&) = delete;
WifiP2P_proxy& operator=(const WifiP2P_proxy&) = delete;
WifiP2P_proxy(WifiP2P_proxy&&) = delete;
WifiP2P_proxy& operator=(WifiP2P_proxy&&) = delete;
~WifiP2P_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("PeerAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerAdded(peer); });
m_proxy.uponSignal("PeerRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerRemoved(peer); });
}
virtual void onPeerAdded(const sdbus::ObjectPath& peer) = 0;
virtual void onPeerRemoved(const sdbus::ObjectPath& peer) = 0;
public:
void StartFind(const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("StartFind").onInterface(INTERFACE_NAME).withArguments(options);
m_proxy.callMethod("StartFind").onInterface(INTERFACE_NAME).withArguments(options);
}
void StopFind()
{
proxy_.callMethod("StopFind").onInterface(INTERFACE_NAME);
m_proxy.callMethod("StopFind").onInterface(INTERFACE_NAME);
}
public:
std::string HwAddress()
{
return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HwAddress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<sdbus::ObjectPath> Peers()
{
return proxy_.getProperty("Peers").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Peers").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/device_wireless_client.h
+26 -17
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_device_wireless_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_device_wireless_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_device_wireless_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_device_wireless_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -22,14 +22,23 @@ public:
protected:
Wireless_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("AccessPointAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointAdded(access_point); });
proxy_.uponSignal("AccessPointRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointRemoved(access_point); });
}
Wireless_proxy(const Wireless_proxy&) = delete;
Wireless_proxy& operator=(const Wireless_proxy&) = delete;
Wireless_proxy(Wireless_proxy&&) = delete;
Wireless_proxy& operator=(Wireless_proxy&&) = delete;
~Wireless_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("AccessPointAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointAdded(access_point); });
m_proxy.uponSignal("AccessPointRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointRemoved(access_point); });
}
virtual void onAccessPointAdded(const sdbus::ObjectPath& access_point) = 0;
virtual void onAccessPointRemoved(const sdbus::ObjectPath& access_point) = 0;
@@ -37,65 +46,65 @@ public:
std::vector<sdbus::ObjectPath> GetAccessPoints()
{
std::vector<sdbus::ObjectPath> result;
proxy_.callMethod("GetAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::vector<sdbus::ObjectPath> GetAllAccessPoints()
{
std::vector<sdbus::ObjectPath> result;
proxy_.callMethod("GetAllAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetAllAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void RequestScan(const std::map<std::string, sdbus::Variant>& options)
{
proxy_.callMethod("RequestScan").onInterface(INTERFACE_NAME).withArguments(options);
m_proxy.callMethod("RequestScan").onInterface(INTERFACE_NAME).withArguments(options);
}
public:
std::string HwAddress()
{
return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("HwAddress").onInterface(INTERFACE_NAME).get<std::string>();
}
std::string PermHwAddress()
{
return proxy_.getProperty("PermHwAddress").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PermHwAddress").onInterface(INTERFACE_NAME).get<std::string>();
}
uint32_t Mode()
{
return proxy_.getProperty("Mode").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Mode").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t Bitrate()
{
return proxy_.getProperty("Bitrate").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Bitrate").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::vector<sdbus::ObjectPath> AccessPoints()
{
return proxy_.getProperty("AccessPoints").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AccessPoints").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
sdbus::ObjectPath ActiveAccessPoint()
{
return proxy_.getProperty("ActiveAccessPoint").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ActiveAccessPoint").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
uint32_t WirelessCapabilities()
{
return proxy_.getProperty("WirelessCapabilities").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WirelessCapabilities").onInterface(INTERFACE_NAME).get<uint32_t>();
}
int64_t LastScan()
{
return proxy_.getProperty("LastScan").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("LastScan").onInterface(INTERFACE_NAME).get<int64_t>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/ip4config_client.h
+26 -17
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_ip4config_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_ip4config_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_ip4config_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_ip4config_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -21,80 +21,89 @@ public:
protected:
IP4Config_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
}
IP4Config_proxy(const IP4Config_proxy&) = delete;
IP4Config_proxy& operator=(const IP4Config_proxy&) = delete;
IP4Config_proxy(IP4Config_proxy&&) = delete;
IP4Config_proxy& operator=(IP4Config_proxy&&) = delete;
~IP4Config_proxy() = default;
void registerProxy()
{
}
public:
std::vector<std::vector<uint32_t>> Addresses()
{
return proxy_.getProperty("Addresses").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Addresses").onInterface(INTERFACE_NAME).get<std::vector<std::vector<uint32_t>>>();
}
std::vector<std::map<std::string, sdbus::Variant>> AddressData()
{
return proxy_.getProperty("AddressData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AddressData").onInterface(INTERFACE_NAME).get<std::vector<std::map<std::string, sdbus::Variant>>>();
}
std::string Gateway()
{
return proxy_.getProperty("Gateway").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Gateway").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<std::vector<uint32_t>> Routes()
{
return proxy_.getProperty("Routes").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Routes").onInterface(INTERFACE_NAME).get<std::vector<std::vector<uint32_t>>>();
}
std::vector<std::map<std::string, sdbus::Variant>> RouteData()
{
return proxy_.getProperty("RouteData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RouteData").onInterface(INTERFACE_NAME).get<std::vector<std::map<std::string, sdbus::Variant>>>();
}
std::vector<uint32_t> Nameservers()
{
return proxy_.getProperty("Nameservers").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Nameservers").onInterface(INTERFACE_NAME).get<std::vector<uint32_t>>();
}
std::vector<std::map<std::string, sdbus::Variant>> NameserverData()
{
return proxy_.getProperty("NameserverData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NameserverData").onInterface(INTERFACE_NAME).get<std::vector<std::map<std::string, sdbus::Variant>>>();
}
std::vector<std::string> Domains()
{
return proxy_.getProperty("Domains").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Domains").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> Searches()
{
return proxy_.getProperty("Searches").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Searches").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
std::vector<std::string> DnsOptions()
{
return proxy_.getProperty("DnsOptions").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("DnsOptions").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
int32_t DnsPriority()
{
return proxy_.getProperty("DnsPriority").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("DnsPriority").onInterface(INTERFACE_NAME).get<int32_t>();
}
std::vector<uint32_t> WinsServers()
{
return proxy_.getProperty("WinsServers").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WinsServers").onInterface(INTERFACE_NAME).get<std::vector<uint32_t>>();
}
std::vector<std::string> WinsServerData()
{
return proxy_.getProperty("WinsServerData").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WinsServerData").onInterface(INTERFACE_NAME).get<std::vector<std::string>>();
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}}} // namespaces
internal/platform/implementation/linux/generated/dbus/networkmanager/networkmanager_client.h
+67 -58
View File
@@ -3,8 +3,8 @@
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
*/
#ifndef __sdbuscpp__networkmanager_client_glue_h__proxy__H__
#define __sdbuscpp__networkmanager_client_glue_h__proxy__H__
#ifndef __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_networkmanager_client_v2_h__proxy__H__
#define __sdbuscpp___home_lasan_Dev_nearby_latest_internal_platform_implementation_linux_generated_dbus_networkmanager_networkmanager_client_v2_h__proxy__H__
#include <sdbus-c++/sdbus-c++.h>
#include <string>
@@ -20,16 +20,25 @@ public:
protected:
NetworkManager_proxy(sdbus::IProxy& proxy)
: proxy_(proxy)
: m_proxy(proxy)
{
proxy_.uponSignal("CheckPermissions").onInterface(INTERFACE_NAME).call([this](){ this->onCheckPermissions(); });
proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state){ this->onStateChanged(state); });
proxy_.uponSignal("DeviceAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceAdded(device_path); });
proxy_.uponSignal("DeviceRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceRemoved(device_path); });
}
NetworkManager_proxy(const NetworkManager_proxy&) = delete;
NetworkManager_proxy& operator=(const NetworkManager_proxy&) = delete;
NetworkManager_proxy(NetworkManager_proxy&&) = delete;
NetworkManager_proxy& operator=(NetworkManager_proxy&&) = delete;
~NetworkManager_proxy() = default;
void registerProxy()
{
m_proxy.uponSignal("CheckPermissions").onInterface(INTERFACE_NAME).call([this](){ this->onCheckPermissions(); });
m_proxy.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state){ this->onStateChanged(state); });
m_proxy.uponSignal("DeviceAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceAdded(device_path); });
m_proxy.uponSignal("DeviceRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceRemoved(device_path); });
}
virtual void onCheckPermissions() = 0;
virtual void onStateChanged(const uint32_t& state) = 0;
virtual void onDeviceAdded(const sdbus::ObjectPath& device_path) = 0;
@@ -38,281 +47,281 @@ protected:
public:
void Reload(const uint32_t& flags)
{
proxy_.callMethod("Reload").onInterface(INTERFACE_NAME).withArguments(flags);
m_proxy.callMethod("Reload").onInterface(INTERFACE_NAME).withArguments(flags);
}
std::vector<sdbus::ObjectPath> GetDevices()
{
std::vector<sdbus::ObjectPath> result;
proxy_.callMethod("GetDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
std::vector<sdbus::ObjectPath> GetAllDevices()
{
std::vector<sdbus::ObjectPath> result;
proxy_.callMethod("GetAllDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetAllDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
sdbus::ObjectPath GetDeviceByIpIface(const std::string& iface)
{
sdbus::ObjectPath result;
proxy_.callMethod("GetDeviceByIpIface").onInterface(INTERFACE_NAME).withArguments(iface).storeResultsTo(result);
m_proxy.callMethod("GetDeviceByIpIface").onInterface(INTERFACE_NAME).withArguments(iface).storeResultsTo(result);
return result;
}
sdbus::ObjectPath ActivateConnection(const sdbus::ObjectPath& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object)
{
sdbus::ObjectPath result;
proxy_.callMethod("ActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
m_proxy.callMethod("ActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
return result;
}
std::tuple<sdbus::ObjectPath, sdbus::ObjectPath> AddAndActivateConnection(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object)
{
std::tuple<sdbus::ObjectPath, sdbus::ObjectPath> result;
proxy_.callMethod("AddAndActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
m_proxy.callMethod("AddAndActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
return result;
}
std::tuple<sdbus::ObjectPath, sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> AddAndActivateConnection2(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object, const std::map<std::string, sdbus::Variant>& options)
{
std::tuple<sdbus::ObjectPath, sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> result;
proxy_.callMethod("AddAndActivateConnection2").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object, options).storeResultsTo(result);
m_proxy.callMethod("AddAndActivateConnection2").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object, options).storeResultsTo(result);
return result;
}
void DeactivateConnection(const sdbus::ObjectPath& active_connection)
{
proxy_.callMethod("DeactivateConnection").onInterface(INTERFACE_NAME).withArguments(active_connection);
m_proxy.callMethod("DeactivateConnection").onInterface(INTERFACE_NAME).withArguments(active_connection);
}
void Sleep(const bool& sleep)
{
proxy_.callMethod("Sleep").onInterface(INTERFACE_NAME).withArguments(sleep);
m_proxy.callMethod("Sleep").onInterface(INTERFACE_NAME).withArguments(sleep);
}
void Enable(const bool& enable)
{
proxy_.callMethod("Enable").onInterface(INTERFACE_NAME).withArguments(enable);
m_proxy.callMethod("Enable").onInterface(INTERFACE_NAME).withArguments(enable);
}
std::map<std::string, std::string> GetPermissions()
{
std::map<std::string, std::string> result;
proxy_.callMethod("GetPermissions").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetPermissions").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
void SetLogging(const std::string& level, const std::string& domains)
{
proxy_.callMethod("SetLogging").onInterface(INTERFACE_NAME).withArguments(level, domains);
m_proxy.callMethod("SetLogging").onInterface(INTERFACE_NAME).withArguments(level, domains);
}
std::tuple<std::string, std::string> GetLogging()
{
std::tuple<std::string, std::string> result;
proxy_.callMethod("GetLogging").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("GetLogging").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t CheckConnectivity()
{
uint32_t result;
proxy_.callMethod("CheckConnectivity").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("CheckConnectivity").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
uint32_t state()
{
uint32_t result;
proxy_.callMethod("state").onInterface(INTERFACE_NAME).storeResultsTo(result);
m_proxy.callMethod("state").onInterface(INTERFACE_NAME).storeResultsTo(result);
return result;
}
sdbus::ObjectPath CheckpointCreate(const std::vector<sdbus::ObjectPath>& devices, const uint32_t& rollback_timeout, const uint32_t& flags)
{
sdbus::ObjectPath result;
proxy_.callMethod("CheckpointCreate").onInterface(INTERFACE_NAME).withArguments(devices, rollback_timeout, flags).storeResultsTo(result);
m_proxy.callMethod("CheckpointCreate").onInterface(INTERFACE_NAME).withArguments(devices, rollback_timeout, flags).storeResultsTo(result);
return result;
}
void CheckpointDestroy(const sdbus::ObjectPath& checkpoint)
{
proxy_.callMethod("CheckpointDestroy").onInterface(INTERFACE_NAME).withArguments(checkpoint);
m_proxy.callMethod("CheckpointDestroy").onInterface(INTERFACE_NAME).withArguments(checkpoint);
}
std::map<std::string, uint32_t> CheckpointRollback(const sdbus::ObjectPath& checkpoint)
{
std::map<std::string, uint32_t> result;
proxy_.callMethod("CheckpointRollback").onInterface(INTERFACE_NAME).withArguments(checkpoint).storeResultsTo(result);
m_proxy.callMethod("CheckpointRollback").onInterface(INTERFACE_NAME).withArguments(checkpoint).storeResultsTo(result);
return result;
}
void CheckpointAdjustRollbackTimeout(const sdbus::ObjectPath& checkpoint, const uint32_t& add_timeout)
{
proxy_.callMethod("CheckpointAdjustRollbackTimeout").onInterface(INTERFACE_NAME).withArguments(checkpoint, add_timeout);
m_proxy.callMethod("CheckpointAdjustRollbackTimeout").onInterface(INTERFACE_NAME).withArguments(checkpoint, add_timeout);
}
public:
std::vector<sdbus::ObjectPath> Devices()
{
return proxy_.getProperty("Devices").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Devices").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
std::vector<sdbus::ObjectPath> AllDevices()
{
return proxy_.getProperty("AllDevices").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("AllDevices").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
std::vector<sdbus::ObjectPath> Checkpoints()
{
return proxy_.getProperty("Checkpoints").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Checkpoints").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
bool NetworkingEnabled()
{
return proxy_.getProperty("NetworkingEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("NetworkingEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
bool WirelessEnabled()
{
return proxy_.getProperty("WirelessEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WirelessEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
void WirelessEnabled(const bool& value)
{
proxy_.setProperty("WirelessEnabled").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("WirelessEnabled").onInterface(INTERFACE_NAME).toValue(value);
}
bool WirelessHardwareEnabled()
{
return proxy_.getProperty("WirelessHardwareEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WirelessHardwareEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
bool WwanEnabled()
{
return proxy_.getProperty("WwanEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WwanEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
void WwanEnabled(const bool& value)
{
proxy_.setProperty("WwanEnabled").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("WwanEnabled").onInterface(INTERFACE_NAME).toValue(value);
}
bool WwanHardwareEnabled()
{
return proxy_.getProperty("WwanHardwareEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WwanHardwareEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
bool WimaxEnabled()
{
return proxy_.getProperty("WimaxEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WimaxEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
void WimaxEnabled(const bool& value)
{
proxy_.setProperty("WimaxEnabled").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("WimaxEnabled").onInterface(INTERFACE_NAME).toValue(value);
}
bool WimaxHardwareEnabled()
{
return proxy_.getProperty("WimaxHardwareEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("WimaxHardwareEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
uint32_t RadioFlags()
{
return proxy_.getProperty("RadioFlags").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("RadioFlags").onInterface(INTERFACE_NAME).get<uint32_t>();
}
std::vector<sdbus::ObjectPath> ActiveConnections()
{
return proxy_.getProperty("ActiveConnections").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ActiveConnections").onInterface(INTERFACE_NAME).get<std::vector<sdbus::ObjectPath>>();
}
sdbus::ObjectPath PrimaryConnection()
{
return proxy_.getProperty("PrimaryConnection").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PrimaryConnection").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
std::string PrimaryConnectionType()
{
return proxy_.getProperty("PrimaryConnectionType").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("PrimaryConnectionType").onInterface(INTERFACE_NAME).get<std::string>();
}
uint32_t Metered()
{
return proxy_.getProperty("Metered").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Metered").onInterface(INTERFACE_NAME).get<uint32_t>();
}
sdbus::ObjectPath ActivatingConnection()
{
return proxy_.getProperty("ActivatingConnection").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ActivatingConnection").onInterface(INTERFACE_NAME).get<sdbus::ObjectPath>();
}
bool Startup()
{
return proxy_.getProperty("Startup").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Startup").onInterface(INTERFACE_NAME).get<bool>();
}
std::string Version()
{
return proxy_.getProperty("Version").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Version").onInterface(INTERFACE_NAME).get<std::string>();
}
std::vector<uint32_t> VersionInfo()
{
return proxy_.getProperty("VersionInfo").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("VersionInfo").onInterface(INTERFACE_NAME).get<std::vector<uint32_t>>();
}
std::vector<uint32_t> Capabilities()
{
return proxy_.getProperty("Capabilities").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Capabilities").onInterface(INTERFACE_NAME).get<std::vector<uint32_t>>();
}
uint32_t State()
{
return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("State").onInterface(INTERFACE_NAME).get<uint32_t>();
}
uint32_t Connectivity()
{
return proxy_.getProperty("Connectivity").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("Connectivity").onInterface(INTERFACE_NAME).get<uint32_t>();
}
bool ConnectivityCheckAvailable()
{
return proxy_.getProperty("ConnectivityCheckAvailable").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ConnectivityCheckAvailable").onInterface(INTERFACE_NAME).get<bool>();
}
bool ConnectivityCheckEnabled()
{
return proxy_.getProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME).get<bool>();
}
void ConnectivityCheckEnabled(const bool& value)
{
proxy_.setProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME).toValue(value);
}
std::string ConnectivityCheckUri()
{
return proxy_.getProperty("ConnectivityCheckUri").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("ConnectivityCheckUri").onInterface(INTERFACE_NAME).get<std::string>();
}
std::map<std::string, sdbus::Variant> GlobalDnsConfiguration()
{
return proxy_.getProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME);
return m_proxy.getProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME).get<std::map<std::string, sdbus::Variant>>();
}
void GlobalDnsConfiguration(const std::map<std::string, sdbus::Variant>& value)
{
proxy_.setProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME).toValue(value);
m_proxy.setProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME).toValue(value);
}
private:
sdbus::IProxy& proxy_;
sdbus::IProxy& m_proxy;
};
}} // namespaces