forked from Kistler-Group/sdbus-cpp
a1419ee45d
This allows nesting variants, i.e. allows a variant to contain another variant as its value. Until now, there was no such possibility, since the default generated copy constructor would be invoked which would create a copy of source variant instead of embed the source variant as a value in the destination variant. The default generated copy constructor is kept, for it makes sense too, but a new tag-based overload is added for embedding the source variant into the destination variant.
261 lines
8.8 KiB
C++
261 lines
8.8 KiB
C++
|
|
/*
|
|
* This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
|
|
*/
|
|
|
|
#ifndef __sdbuscpp__integrationtests_proxy_h__proxy__H__
|
|
#define __sdbuscpp__integrationtests_proxy_h__proxy__H__
|
|
|
|
#include <sdbus-c++/sdbus-c++.h>
|
|
#include <string>
|
|
#include <tuple>
|
|
|
|
namespace org {
|
|
namespace sdbuscpp {
|
|
|
|
class integrationtests_proxy
|
|
{
|
|
public:
|
|
static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
|
|
|
|
protected:
|
|
integrationtests_proxy(sdbus::IProxy& proxy)
|
|
: m_proxy(proxy)
|
|
{
|
|
}
|
|
|
|
integrationtests_proxy(const integrationtests_proxy&) = delete;
|
|
integrationtests_proxy& operator=(const integrationtests_proxy&) = delete;
|
|
integrationtests_proxy(integrationtests_proxy&&) = delete;
|
|
integrationtests_proxy& operator=(integrationtests_proxy&&) = delete;
|
|
|
|
~integrationtests_proxy() = default;
|
|
|
|
void registerProxy()
|
|
{
|
|
simpleSignalSlot_ = m_proxy.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); }, sdbus::return_slot);
|
|
m_proxy.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
|
|
m_proxy.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
|
|
}
|
|
|
|
virtual void onSimpleSignal() = 0;
|
|
virtual void onSignalWithMap(const std::map<int32_t, std::string>& aMap) = 0;
|
|
virtual void onSignalWithVariant(const sdbus::Variant& aVariant) = 0;
|
|
|
|
public:
|
|
void noArgNoReturn()
|
|
{
|
|
m_proxy.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
|
|
}
|
|
|
|
int32_t getInt()
|
|
{
|
|
int32_t result;
|
|
m_proxy.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::tuple<uint32_t, std::string> getTuple()
|
|
{
|
|
std::tuple<uint32_t, std::string> result;
|
|
m_proxy.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
double multiply(const int64_t& a, const double& b)
|
|
{
|
|
double result;
|
|
m_proxy.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
void multiplyWithNoReply(const int64_t& a, const double& b)
|
|
{
|
|
m_proxy.callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
|
|
}
|
|
|
|
std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0)
|
|
{
|
|
std::vector<int16_t> result;
|
|
m_proxy.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
sdbus::Variant processVariant(const sdbus::Variant& variant)
|
|
{
|
|
sdbus::Variant result;
|
|
m_proxy.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::variant<int32_t, double, std::string> processVariant(const std::variant<int32_t, double, std::string>& variant)
|
|
{
|
|
std::variant<int32_t, double, std::string> result;
|
|
m_proxy.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
|
|
{
|
|
std::map<int32_t, sdbus::Variant> result;
|
|
m_proxy.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
|
|
{
|
|
sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
|
|
m_proxy.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1)
|
|
{
|
|
int32_t result;
|
|
m_proxy.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
uint32_t sumArrayItems(const std::vector<uint16_t>& arg0, const std::array<uint64_t, 3>& arg1)
|
|
{
|
|
uint32_t result;
|
|
m_proxy.callMethod("sumArrayItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
uint32_t doOperation(const uint32_t& arg0)
|
|
{
|
|
uint32_t result;
|
|
m_proxy.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::map<int32_t, std::string> doOperationWithLargeData(const std::map<int32_t, std::string>& largeParam)
|
|
{
|
|
std::map<int32_t, std::string> result;
|
|
m_proxy.callMethod("doOperationWithLargeData").onInterface(INTERFACE_NAME).withArguments(largeParam).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
uint32_t doOperationAsync(const uint32_t& arg0)
|
|
{
|
|
uint32_t result;
|
|
m_proxy.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::map<int32_t, std::string> doOperationAsyncWithLargeData(const uint32_t& arg0, const std::map<int32_t, std::string>& largeParam)
|
|
{
|
|
std::map<int32_t, std::string> result;
|
|
m_proxy.callMethod("doOperationAsyncWithLargeData").onInterface(INTERFACE_NAME).withArguments(arg0, largeParam).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
sdbus::Signature getSignature()
|
|
{
|
|
sdbus::Signature result;
|
|
m_proxy.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
sdbus::ObjectPath getObjPath()
|
|
{
|
|
sdbus::ObjectPath result;
|
|
m_proxy.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
sdbus::UnixFd getUnixFd()
|
|
{
|
|
sdbus::UnixFd result;
|
|
m_proxy.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::unordered_map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex()
|
|
{
|
|
std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::unordered_map<int32_t, std::string>>>>, sdbus::Signature, std::string>> result;
|
|
m_proxy.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
|
|
return result;
|
|
}
|
|
|
|
void throwError()
|
|
{
|
|
m_proxy.callMethod("throwError").onInterface(INTERFACE_NAME);
|
|
}
|
|
|
|
void throwErrorWithNoReply()
|
|
{
|
|
m_proxy.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
|
|
}
|
|
|
|
void doPrivilegedStuff()
|
|
{
|
|
m_proxy.callMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME);
|
|
}
|
|
|
|
void emitTwoSimpleSignals()
|
|
{
|
|
m_proxy.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
|
|
}
|
|
|
|
void sendLargeMessage(const std::map<int, std::string>& collection)
|
|
{
|
|
m_proxy.callMethod("sendLargeMessage").onInterface(INTERFACE_NAME).withArguments(collection);
|
|
}
|
|
|
|
void unregisterSimpleSignalHandler()
|
|
{
|
|
simpleSignalSlot_.reset();
|
|
}
|
|
|
|
void reRegisterSimpleSignalHandler()
|
|
{
|
|
simpleSignalSlot_ = m_proxy.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); }, sdbus::return_slot);
|
|
}
|
|
|
|
public:
|
|
uint32_t action()
|
|
{
|
|
return m_proxy.getProperty("action").onInterface(INTERFACE_NAME).get<uint32_t>();
|
|
}
|
|
|
|
void action(const uint32_t& value)
|
|
{
|
|
m_proxy.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
|
|
}
|
|
|
|
sdbus::Variant actionVariant()
|
|
{
|
|
return m_proxy.getProperty("actionVariant").onInterface(INTERFACE_NAME).get<sdbus::Variant>();
|
|
}
|
|
|
|
void actionVariant(const sdbus::Variant& value)
|
|
{
|
|
m_proxy.setProperty("actionVariant").onInterface(INTERFACE_NAME).toValue({value, sdbus::embed_variant});
|
|
}
|
|
|
|
bool blocking()
|
|
{
|
|
return m_proxy.getProperty("blocking").onInterface(INTERFACE_NAME).get<bool>();
|
|
}
|
|
|
|
void blocking(const bool& value)
|
|
{
|
|
m_proxy.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
|
|
}
|
|
|
|
std::string state()
|
|
{
|
|
return m_proxy.getProperty("state").onInterface(INTERFACE_NAME).get<std::string>();
|
|
}
|
|
|
|
private:
|
|
sdbus::IProxy& m_proxy;
|
|
sdbus::Slot simpleSignalSlot_;
|
|
};
|
|
|
|
}} // namespaces
|
|
|
|
#endif
|