forked from Kistler-Group/sdbus-cpp
302 lines
9.2 KiB
C++
302 lines
9.2 KiB
C++
/**
|
|
* (C) 2016 - 2024 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
|
|
*
|
|
* @file VTableItems.inl
|
|
*
|
|
* Created on: Dec 14, 2023
|
|
* Project: sdbus-c++
|
|
* Description: High-level D-Bus IPC C++ library based on sd-bus
|
|
*
|
|
* This file is part of sdbus-c++.
|
|
*
|
|
* sdbus-c++ is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 2.1 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* sdbus-c++ is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef SDBUS_CPP_VTABLEITEMS_INL_
|
|
#define SDBUS_CPP_VTABLEITEMS_INL_
|
|
|
|
#include <sdbus-c++/Error.h>
|
|
#include <sdbus-c++/TypeTraits.h>
|
|
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace sdbus {
|
|
|
|
/*** -------------------- ***/
|
|
/*** Method VTable Item ***/
|
|
/*** -------------------- ***/
|
|
|
|
template <typename _Function>
|
|
MethodVTableItem& MethodVTableItem::implementedAs(_Function&& callback)
|
|
{
|
|
inputSignature = signature_of_function_input_arguments_v<_Function>;
|
|
outputSignature = signature_of_function_output_arguments_v<_Function>;
|
|
callbackHandler = [callback = std::forward<_Function>(callback)](MethodCall call)
|
|
{
|
|
// Create a tuple of callback input arguments' types, which will be used
|
|
// as a storage for the argument values deserialized from the message.
|
|
tuple_of_function_input_arg_types_t<_Function> inputArgs;
|
|
|
|
// Deserialize input arguments from the message into the tuple.
|
|
call >> inputArgs;
|
|
|
|
if constexpr (!is_async_method_v<_Function>)
|
|
{
|
|
// Invoke callback with input arguments from the tuple.
|
|
auto ret = sdbus::apply(callback, inputArgs);
|
|
|
|
// Store output arguments to the reply message and send it back.
|
|
auto reply = call.createReply();
|
|
reply << ret;
|
|
reply.send();
|
|
}
|
|
else
|
|
{
|
|
// Invoke callback with input arguments from the tuple and with result object to be set later
|
|
using AsyncResult = typename function_traits<_Function>::async_result_t;
|
|
sdbus::apply(callback, AsyncResult{std::move(call)}, std::move(inputArgs));
|
|
}
|
|
};
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline MethodVTableItem& MethodVTableItem::withInputParamNames(std::vector<std::string> names)
|
|
{
|
|
inputParamNames = std::move(names);
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename... _String>
|
|
inline MethodVTableItem& MethodVTableItem::withInputParamNames(_String... names)
|
|
{
|
|
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
|
|
|
|
return withInputParamNames({names...});
|
|
}
|
|
|
|
inline MethodVTableItem& MethodVTableItem::withOutputParamNames(std::vector<std::string> names)
|
|
{
|
|
outputParamNames = std::move(names);
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename... _String>
|
|
inline MethodVTableItem& MethodVTableItem::withOutputParamNames(_String... names)
|
|
{
|
|
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
|
|
|
|
return withOutputParamNames({names...});
|
|
}
|
|
|
|
inline MethodVTableItem& MethodVTableItem::markAsDeprecated()
|
|
{
|
|
flags.set(Flags::DEPRECATED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline MethodVTableItem& MethodVTableItem::markAsPrivileged()
|
|
{
|
|
flags.set(Flags::PRIVILEGED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline MethodVTableItem& MethodVTableItem::withNoReply()
|
|
{
|
|
flags.set(Flags::METHOD_NO_REPLY);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline MethodVTableItem registerMethod(MethodName methodName)
|
|
{
|
|
return {std::move(methodName), {}, {}, {}, {}, {}, {}};
|
|
}
|
|
|
|
inline MethodVTableItem registerMethod(std::string methodName)
|
|
{
|
|
return registerMethod(MethodName{std::move(methodName)});
|
|
}
|
|
|
|
/*** -------------------- ***/
|
|
/*** Signal VTable Item ***/
|
|
/*** -------------------- ***/
|
|
|
|
template <typename... _Args>
|
|
inline SignalVTableItem& SignalVTableItem::withParameters()
|
|
{
|
|
signature = signature_of_function_input_arguments_v<void(_Args...)>;
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename... _Args>
|
|
inline SignalVTableItem& SignalVTableItem::withParameters(std::vector<std::string> names)
|
|
{
|
|
paramNames = std::move(names);
|
|
|
|
return withParameters<_Args...>();
|
|
}
|
|
|
|
template <typename... _Args, typename... _String>
|
|
inline SignalVTableItem& SignalVTableItem::withParameters(_String... names)
|
|
{
|
|
static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
|
|
static_assert(sizeof...(_Args) == sizeof...(_String), "Numbers of signal parameters and their names don't match");
|
|
|
|
return withParameters<_Args...>({names...});
|
|
}
|
|
|
|
inline SignalVTableItem& SignalVTableItem::markAsDeprecated()
|
|
{
|
|
flags.set(Flags::DEPRECATED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline SignalVTableItem registerSignal(SignalName signalName)
|
|
{
|
|
return {std::move(signalName), {}, {}, {}};
|
|
}
|
|
|
|
inline SignalVTableItem registerSignal(std::string signalName)
|
|
{
|
|
return registerSignal(SignalName{std::move(signalName)});
|
|
}
|
|
|
|
/*** -------------------- ***/
|
|
/*** Property VTable Item ***/
|
|
/*** -------------------- ***/
|
|
|
|
template <typename _Function>
|
|
inline PropertyVTableItem& PropertyVTableItem::withGetter(_Function&& callback)
|
|
{
|
|
static_assert(function_argument_count_v<_Function> == 0, "Property getter function must not take any arguments");
|
|
static_assert(!std::is_void<function_result_t<_Function>>::value, "Property getter function must return property value");
|
|
|
|
if (signature.empty())
|
|
signature = signature_of_function_output_arguments_v<_Function>;
|
|
|
|
getter = [callback = std::forward<_Function>(callback)](PropertyGetReply& reply)
|
|
{
|
|
// Get the propety value and serialize it into the pre-constructed reply message
|
|
reply << callback();
|
|
};
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename _Function>
|
|
inline PropertyVTableItem& PropertyVTableItem::withSetter(_Function&& callback)
|
|
{
|
|
static_assert(function_argument_count_v<_Function> == 1, "Property setter function must take one parameter - the property value");
|
|
static_assert(std::is_void<function_result_t<_Function>>::value, "Property setter function must not return any value");
|
|
|
|
if (signature.empty())
|
|
signature = signature_of_function_input_arguments_v<_Function>;
|
|
|
|
setter = [callback = std::forward<_Function>(callback)](PropertySetCall call)
|
|
{
|
|
// Default-construct property value
|
|
using property_type = function_argument_t<_Function, 0>;
|
|
std::decay_t<property_type> property;
|
|
|
|
// Deserialize property value from the incoming call message
|
|
call >> property;
|
|
|
|
// Invoke setter with the value
|
|
callback(property);
|
|
};
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline PropertyVTableItem& PropertyVTableItem::markAsDeprecated()
|
|
{
|
|
flags.set(Flags::DEPRECATED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline PropertyVTableItem& PropertyVTableItem::markAsPrivileged()
|
|
{
|
|
flags.set(Flags::PRIVILEGED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline PropertyVTableItem& PropertyVTableItem::withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
|
|
{
|
|
flags.set(behavior);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline PropertyVTableItem registerProperty(PropertyName propertyName)
|
|
{
|
|
return {std::move(propertyName), {}, {}, {}, {}};
|
|
}
|
|
|
|
inline PropertyVTableItem registerProperty(std::string propertyName)
|
|
{
|
|
return registerProperty(PropertyName{std::move(propertyName)});
|
|
}
|
|
|
|
/*** --------------------------- ***/
|
|
/*** Interface Flags VTable Item ***/
|
|
/*** --------------------------- ***/
|
|
|
|
inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::markAsDeprecated()
|
|
{
|
|
flags.set(Flags::DEPRECATED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::markAsPrivileged()
|
|
{
|
|
flags.set(Flags::PRIVILEGED);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::withNoReplyMethods()
|
|
{
|
|
flags.set(Flags::METHOD_NO_REPLY);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
|
|
{
|
|
flags.set(behavior);
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline InterfaceFlagsVTableItem setInterfaceFlags()
|
|
{
|
|
return {};
|
|
}
|
|
|
|
} // namespace sdbus
|
|
|
|
#endif /* SDBUS_CPP_VTABLEITEMS_INL_ */
|