Update repo to conform to openbmc code standard
Change-Id: If1d6b1f04514367cc544c2507a845b3e9d6d3435
Signed-off-by: Andrew Geissler <geissonator@yahoo.com>
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..309a9d6
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,85 @@
+---
+Language: Cpp
+# BasedOnStyle: LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+ AfterClass: true
+ AfterControlStatement: true
+ AfterEnum: true
+ AfterFunction: true
+ AfterNamespace: true
+ AfterObjCDeclaration: true
+ AfterStruct: true
+ AfterUnion: true
+ BeforeCatch: true
+ BeforeElse: true
+ IndentBraces: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+PointerAlignment: Left
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IndentCaseLabels: true
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments: true
+SortIncludes: false
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp11
+TabWidth: 4
+UseTab: Never
+...
+
diff --git a/example/calculator-server.cpp b/example/calculator-server.cpp
index e72c493..753d2d7 100644
--- a/example/calculator-server.cpp
+++ b/example/calculator-server.cpp
@@ -3,20 +3,22 @@
#include <net/poettering/Calculator/server.hpp>
#include <net/poettering/Calculator/error.hpp>
-using Calculator_inherit = sdbusplus::server::object_t<
- sdbusplus::net::poettering::server::Calculator>;
+using Calculator_inherit =
+ sdbusplus::server::object_t<sdbusplus::net::poettering::server::Calculator>;
/** Example implementation of net.poettering.Calculator */
struct Calculator : Calculator_inherit
{
/** Constructor */
Calculator(sdbusplus::bus::bus& bus, const char* path) :
- Calculator_inherit(bus, path) { }
+ Calculator_inherit(bus, path)
+ {
+ }
/** Multiply (x*y), update lastResult */
int64_t multiply(int64_t x, int64_t y) override
{
- return lastResult(x*y);
+ return lastResult(x * y);
}
/** Divide (x/y), update lastResult
@@ -32,7 +34,7 @@
throw DivisionByZero();
}
- return lastResult(x/y);
+ return lastResult(x / y);
}
/** Clear lastResult, broadcast 'Cleared' signal */
@@ -62,7 +64,7 @@
Calculator c1{b, path};
// Handle dbus processing forever.
- while(1)
+ while (1)
{
b.process_discard(); // discard any unhandled messages
b.wait();
diff --git a/example/list-users.cpp b/example/list-users.cpp
index 245bf63..d5e59d6 100644
--- a/example/list-users.cpp
+++ b/example/list-users.cpp
@@ -12,16 +12,15 @@
using namespace sdbusplus;
auto b = bus::new_system();
- auto m = b.new_method_call("org.freedesktop.login1",
- "/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- "ListUsers");
+ auto m =
+ b.new_method_call("org.freedesktop.login1", "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager", "ListUsers");
auto reply = b.call(m);
std::vector<std::tuple<uint32_t, std::string, message::object_path>> users;
reply.read(users);
- for(auto& user : users)
+ for (auto& user : users)
{
std::cout << std::get<std::string>(user) << "\n";
}
diff --git a/mapbox/recursive_wrapper.hpp b/mapbox/recursive_wrapper.hpp
index 4ffcbd7..af569ef 100644
--- a/mapbox/recursive_wrapper.hpp
+++ b/mapbox/recursive_wrapper.hpp
@@ -15,11 +15,12 @@
#include <cassert>
#include <utility>
-namespace mapbox {
-namespace util {
+namespace mapbox
+{
+namespace util
+{
-template <typename T>
-class recursive_wrapper
+template <typename T> class recursive_wrapper
{
T* p_;
@@ -29,7 +30,7 @@
this->get() = rhs;
}
-public:
+ public:
using type = T;
/**
@@ -41,22 +42,32 @@
* of type T.
* @throws any exception thrown by the default constructur of T.
*/
- recursive_wrapper()
- : p_(new T){}
+ recursive_wrapper() : p_(new T)
+ {
+ }
- ~recursive_wrapper() noexcept { delete p_; }
+ ~recursive_wrapper() noexcept
+ {
+ delete p_;
+ }
- recursive_wrapper(recursive_wrapper const& operand)
- : p_(new T(operand.get())) {}
+ recursive_wrapper(recursive_wrapper const& operand) :
+ p_(new T(operand.get()))
+ {
+ }
- recursive_wrapper(T const& operand)
- : p_(new T(operand)) {}
+ recursive_wrapper(T const& operand) : p_(new T(operand))
+ {
+ }
- recursive_wrapper(recursive_wrapper&& operand)
- : p_(new T(std::move(operand.get()))) {}
+ recursive_wrapper(recursive_wrapper&& operand) :
+ p_(new T(std::move(operand.get())))
+ {
+ }
- recursive_wrapper(T&& operand)
- : p_(new T(std::move(operand))) {}
+ recursive_wrapper(T&& operand) : p_(new T(std::move(operand)))
+ {
+ }
inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
{
@@ -101,13 +112,25 @@
return *get_pointer();
}
- T* get_pointer() { return p_; }
+ T* get_pointer()
+ {
+ return p_;
+ }
- const T* get_pointer() const { return p_; }
+ const T* get_pointer() const
+ {
+ return p_;
+ }
- operator T const&() const { return this->get(); }
+ operator T const&() const
+ {
+ return this->get();
+ }
- operator T&() { return this->get(); }
+ operator T&()
+ {
+ return this->get();
+ }
}; // class recursive_wrapper
diff --git a/mapbox/variant.hpp b/mapbox/variant.hpp
index 5574b67..37c736d 100644
--- a/mapbox/variant.hpp
+++ b/mapbox/variant.hpp
@@ -45,7 +45,7 @@
// clang-format on
// Exceptions
-#if defined( __EXCEPTIONS) || defined( _MSC_VER)
+#if defined(__EXCEPTIONS) || defined(_MSC_VER)
#define HAS_EXCEPTIONS
#endif
@@ -53,52 +53,61 @@
#define VARIANT_MINOR_VERSION 1
#define VARIANT_PATCH_VERSION 0
-#define VARIANT_VERSION (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + (VARIANT_PATCH_VERSION)
+#define VARIANT_VERSION \
+ (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + \
+ (VARIANT_PATCH_VERSION)
-namespace mapbox {
-namespace util {
+namespace mapbox
+{
+namespace util
+{
// XXX This should derive from std::logic_error instead of std::runtime_error.
// See https://github.com/mapbox/variant/issues/48 for details.
class bad_variant_access : public std::runtime_error
{
-public:
- explicit bad_variant_access(const std::string& what_arg)
- : runtime_error(what_arg) {}
+ public:
+ explicit bad_variant_access(const std::string& what_arg) :
+ runtime_error(what_arg)
+ {
+ }
- explicit bad_variant_access(const char* what_arg)
- : runtime_error(what_arg) {}
+ explicit bad_variant_access(const char* what_arg) : runtime_error(what_arg)
+ {
+ }
}; // class bad_variant_access
-template <typename R = void>
-struct MAPBOX_VARIANT_DEPRECATED static_visitor
+template <typename R = void> struct MAPBOX_VARIANT_DEPRECATED static_visitor
{
using result_type = R;
-protected:
- static_visitor() {}
- ~static_visitor() {}
+ protected:
+ static_visitor()
+ {
+ }
+ ~static_visitor()
+ {
+ }
};
-namespace detail {
+namespace detail
+{
static constexpr std::size_t invalid_value = std::size_t(-1);
-template <typename T, typename... Types>
-struct direct_type;
+template <typename T, typename... Types> struct direct_type;
template <typename T, typename First, typename... Types>
struct direct_type<T, First, Types...>
{
static constexpr std::size_t index = std::is_same<T, First>::value
- ? sizeof...(Types)
- : direct_type<T, Types...>::index;
+ ? sizeof...(Types)
+ : direct_type<T, Types...>::index;
};
-template <typename T>
-struct direct_type<T>
+template <typename T> struct direct_type<T>
{
static constexpr std::size_t index = invalid_value;
};
@@ -109,51 +118,63 @@
#else
-template <typename...>
-struct disjunction : std::false_type {};
+template <typename...> struct disjunction : std::false_type
+{
+};
-template <typename B1>
-struct disjunction<B1> : B1 {};
+template <typename B1> struct disjunction<B1> : B1
+{
+};
template <typename B1, typename B2>
-struct disjunction<B1, B2> : std::conditional<B1::value, B1, B2>::type {};
+struct disjunction<B1, B2> : std::conditional<B1::value, B1, B2>::type
+{
+};
template <typename B1, typename... Bs>
-struct disjunction<B1, Bs...> : std::conditional<B1::value, B1, disjunction<Bs...>>::type {};
+struct disjunction<B1, Bs...>
+ : std::conditional<B1::value, B1, disjunction<Bs...>>::type
+{
+};
#endif
-template <typename T, typename... Types>
-struct convertible_type;
+template <typename T, typename... Types> struct convertible_type;
template <typename T, typename First, typename... Types>
struct convertible_type<T, First, Types...>
{
- static constexpr std::size_t index = std::is_convertible<T, First>::value
- ? disjunction<std::is_convertible<T, Types>...>::value ? invalid_value : sizeof...(Types)
- : convertible_type<T, Types...>::index;
+ static constexpr std::size_t index =
+ std::is_convertible<T, First>::value
+ ? disjunction<std::is_convertible<T, Types>...>::value
+ ? invalid_value
+ : sizeof...(Types)
+ : convertible_type<T, Types...>::index;
};
-template <typename T>
-struct convertible_type<T>
+template <typename T> struct convertible_type<T>
{
static constexpr std::size_t index = invalid_value;
};
-template <typename T, typename... Types>
-struct value_traits
+template <typename T, typename... Types> struct value_traits
{
- using value_type = typename std::remove_const<typename std::remove_reference<T>::type>::type;
- static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
+ using value_type = typename std::remove_const<
+ typename std::remove_reference<T>::type>::type;
+ static constexpr std::size_t direct_index =
+ direct_type<value_type, Types...>::index;
static constexpr bool is_direct = direct_index != invalid_value;
- static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
+ static constexpr std::size_t index =
+ is_direct ? direct_index
+ : convertible_type<value_type, Types...>::index;
static constexpr bool is_valid = index != invalid_value;
- static constexpr std::size_t tindex = is_valid ? sizeof...(Types)-index : 0;
- using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
+ static constexpr std::size_t tindex =
+ is_valid ? sizeof...(Types) - index : 0;
+ using target_type =
+ typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
};
-template <typename T, typename R = void>
-struct enable_if_type
+template <typename T, typename R = void> struct enable_if_type
{
using type = R;
};
@@ -165,7 +186,8 @@
};
template <typename F, typename V>
-struct result_of_unary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+struct result_of_unary_visit<
+ F, V, typename enable_if_type<typename F::result_type>::type>
{
using type = typename F::result_type;
};
@@ -177,16 +199,15 @@
};
template <typename F, typename V>
-struct result_of_binary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+struct result_of_binary_visit<
+ F, V, typename enable_if_type<typename F::result_type>::type>
{
using type = typename F::result_type;
};
-template <std::size_t arg1, std::size_t... others>
-struct static_max;
+template <std::size_t arg1, std::size_t... others> struct static_max;
-template <std::size_t arg>
-struct static_max<arg>
+template <std::size_t arg> struct static_max<arg>
{
static const std::size_t value = arg;
};
@@ -194,14 +215,14 @@
template <std::size_t arg1, std::size_t arg2, std::size_t... others>
struct static_max<arg1, arg2, others...>
{
- static const std::size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;
+ static const std::size_t value = arg1 >= arg2
+ ? static_max<arg1, others...>::value
+ : static_max<arg2, others...>::value;
};
-template <typename... Types>
-struct variant_helper;
+template <typename... Types> struct variant_helper;
-template <typename T, typename... Types>
-struct variant_helper<T, Types...>
+template <typename T, typename... Types> struct variant_helper<T, Types...>
{
VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
{
@@ -215,7 +236,8 @@
}
}
- VARIANT_INLINE static void move(const std::size_t old_type_index, void* old_value, void* new_value)
+ VARIANT_INLINE static void move(const std::size_t old_type_index,
+ void* old_value, void* new_value)
{
if (old_type_index == sizeof...(Types))
{
@@ -223,11 +245,13 @@
}
else
{
- variant_helper<Types...>::move(old_type_index, old_value, new_value);
+ variant_helper<Types...>::move(old_type_index, old_value,
+ new_value);
}
}
- VARIANT_INLINE static void copy(const std::size_t old_type_index, const void* old_value, void* new_value)
+ VARIANT_INLINE static void copy(const std::size_t old_type_index,
+ const void* old_value, void* new_value)
{
if (old_type_index == sizeof...(Types))
{
@@ -235,51 +259,60 @@
}
else
{
- variant_helper<Types...>::copy(old_type_index, old_value, new_value);
+ variant_helper<Types...>::copy(old_type_index, old_value,
+ new_value);
}
}
};
-template <>
-struct variant_helper<>
+template <> struct variant_helper<>
{
- VARIANT_INLINE static void destroy(const std::size_t, void*) {}
- VARIANT_INLINE static void move(const std::size_t, void*, void*) {}
- VARIANT_INLINE static void copy(const std::size_t, const void*, void*) {}
+ VARIANT_INLINE static void destroy(const std::size_t, void*)
+ {
+ }
+ VARIANT_INLINE static void move(const std::size_t, void*, void*)
+ {
+ }
+ VARIANT_INLINE static void copy(const std::size_t, const void*, void*)
+ {
+ }
};
-template <typename T>
-struct unwrapper
+template <typename T> struct unwrapper
{
- static T const& apply_const(T const& obj) { return obj; }
- static T& apply(T& obj) { return obj; }
+ static T const& apply_const(T const& obj)
+ {
+ return obj;
+ }
+ static T& apply(T& obj)
+ {
+ return obj;
+ }
};
-template <typename T>
-struct unwrapper<recursive_wrapper<T>>
+template <typename T> struct unwrapper<recursive_wrapper<T>>
{
- static auto apply_const(recursive_wrapper<T> const& obj)
- -> typename recursive_wrapper<T>::type const&
+ static auto apply_const(recursive_wrapper<T> const& obj) ->
+ typename recursive_wrapper<T>::type const&
{
return obj.get();
}
- static auto apply(recursive_wrapper<T>& obj)
- -> typename recursive_wrapper<T>::type&
+ static auto apply(recursive_wrapper<T>& obj) ->
+ typename recursive_wrapper<T>::type&
{
return obj.get();
}
};
-template <typename T>
-struct unwrapper<std::reference_wrapper<T>>
+template <typename T> struct unwrapper<std::reference_wrapper<T>>
{
- static auto apply_const(std::reference_wrapper<T> const& obj)
- -> typename std::reference_wrapper<T>::type const&
+ static auto apply_const(std::reference_wrapper<T> const& obj) ->
+ typename std::reference_wrapper<T>::type const&
{
return obj.get();
}
- static auto apply(std::reference_wrapper<T>& obj)
- -> typename std::reference_wrapper<T>::type&
+ static auto apply(std::reference_wrapper<T>& obj) ->
+ typename std::reference_wrapper<T>::type&
{
return obj.get();
}
@@ -299,7 +332,8 @@
}
else
{
- return dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+ return dispatcher<F, V, R, Types...>::apply_const(
+ v, std::forward<F>(f));
}
}
@@ -333,19 +367,22 @@
template <typename F, typename V, typename R, typename T, typename... Types>
struct binary_dispatcher_rhs;
-template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+template <typename F, typename V, typename R, typename T0, typename T1,
+ typename... Types>
struct binary_dispatcher_rhs<F, V, R, T0, T1, Types...>
{
VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
{
if (rhs.template is<T1>()) // call binary functor
{
- return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
- unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
+ return f(
+ unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
+ unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
}
else
{
- return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+ return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(
+ lhs, rhs, std::forward<F>(f));
}
}
@@ -358,7 +395,8 @@
}
else
{
- return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+ return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(
+ lhs, rhs, std::forward<F>(f));
}
}
};
@@ -382,19 +420,22 @@
template <typename F, typename V, typename R, typename T, typename... Types>
struct binary_dispatcher_lhs;
-template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+template <typename F, typename V, typename R, typename T0, typename T1,
+ typename... Types>
struct binary_dispatcher_lhs<F, V, R, T0, T1, Types...>
{
VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
{
if (lhs.template is<T1>()) // call binary functor
{
- return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
- unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
+ return f(
+ unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
+ unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
}
else
{
- return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+ return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(
+ lhs, rhs, std::forward<F>(f));
}
}
@@ -407,7 +448,8 @@
}
else
{
- return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+ return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(
+ lhs, rhs, std::forward<F>(f));
}
}
};
@@ -440,19 +482,24 @@
{
if (v1.template is<T>())
{
- return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
- unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
+ return f(
+ unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
+ unwrapper<T>::apply_const(
+ v1.template get_unchecked<T>())); // call binary functor
}
else
{
- return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(
+ v0, v1, std::forward<F>(f));
}
}
else if (v1.template is<T>())
{
- return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(
+ v0, v1, std::forward<F>(f));
}
- return binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ return binary_dispatcher<F, V, R, Types...>::apply_const(
+ v0, v1, std::forward<F>(f));
}
VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
@@ -461,19 +508,24 @@
{
if (v1.template is<T>())
{
- return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
- unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
+ return f(
+ unwrapper<T>::apply(v0.template get_unchecked<T>()),
+ unwrapper<T>::apply(
+ v1.template get_unchecked<T>())); // call binary functor
}
else
{
- return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+ return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(
+ v0, v1, std::forward<F>(f));
}
}
else if (v1.template is<T>())
{
- return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+ return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(
+ v0, v1, std::forward<F>(f));
}
- return binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+ return binary_dispatcher<F, V, R, Types...>::apply(v0, v1,
+ std::forward<F>(f));
}
};
@@ -483,21 +535,22 @@
VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
{
return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
- unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
+ unwrapper<T>::apply_const(
+ v1.template get_unchecked<T>())); // call binary functor
}
VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
{
return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
- unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
+ unwrapper<T>::apply(
+ v1.template get_unchecked<T>())); // call binary functor
}
};
// comparator functors
struct equal_comp
{
- template <typename T>
- bool operator()(T const& lhs, T const& rhs) const
+ template <typename T> bool operator()(T const& lhs, T const& rhs) const
{
return lhs == rhs;
}
@@ -505,29 +558,27 @@
struct less_comp
{
- template <typename T>
- bool operator()(T const& lhs, T const& rhs) const
+ template <typename T> bool operator()(T const& lhs, T const& rhs) const
{
return lhs < rhs;
}
};
-template <typename Variant, typename Comp>
-class comparer
+template <typename Variant, typename Comp> class comparer
{
-public:
- explicit comparer(Variant const& lhs) noexcept
- : lhs_(lhs) {}
+ public:
+ explicit comparer(Variant const& lhs) noexcept : lhs_(lhs)
+ {
+ }
comparer& operator=(comparer const&) = delete;
// visitor
- template <typename T>
- bool operator()(T const& rhs_content) const
+ template <typename T> bool operator()(T const& rhs_content) const
{
T const& lhs_content = lhs_.template get_unchecked<T>();
return Comp()(lhs_content, rhs_content);
}
-private:
+ private:
Variant const& lhs_;
};
@@ -537,56 +588,69 @@
{
};
-template <typename... Types>
-class variant
+template <typename... Types> class variant
{
- static_assert(sizeof...(Types) > 0, "Template parameter type list of variant can not be empty");
- static_assert(!detail::disjunction<std::is_reference<Types>...>::value, "Variant can not hold reference types. Maybe use std::reference_wrapper?");
+ static_assert(sizeof...(Types) > 0,
+ "Template parameter type list of variant can not be empty");
+ static_assert(!detail::disjunction<std::is_reference<Types>...>::value,
+ "Variant can not hold reference types. Maybe use "
+ "std::reference_wrapper?");
-private:
- static const std::size_t data_size = detail::static_max<sizeof(Types)...>::value;
- static const std::size_t data_align = detail::static_max<alignof(Types)...>::value;
+ private:
+ static const std::size_t data_size =
+ detail::static_max<sizeof(Types)...>::value;
+ static const std::size_t data_align =
+ detail::static_max<alignof(Types)...>::value;
- using first_type = typename std::tuple_element<0, std::tuple<Types...>>::type;
- using data_type = typename std::aligned_storage<data_size, data_align>::type;
+ using first_type =
+ typename std::tuple_element<0, std::tuple<Types...>>::type;
+ using data_type =
+ typename std::aligned_storage<data_size, data_align>::type;
using helper_type = detail::variant_helper<Types...>;
std::size_t type_index;
data_type data;
-public:
- VARIANT_INLINE variant() noexcept(std::is_nothrow_default_constructible<first_type>::value)
- : type_index(sizeof...(Types)-1)
+ public:
+ VARIANT_INLINE variant() noexcept(
+ std::is_nothrow_default_constructible<first_type>::value) :
+ type_index(sizeof...(Types) - 1)
{
- static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
+ static_assert(std::is_default_constructible<first_type>::value,
+ "First type in variant must be default constructible to "
+ "allow default construction of variant");
new (&data) first_type();
}
- VARIANT_INLINE variant(no_init) noexcept
- : type_index(detail::invalid_value) {}
+ VARIANT_INLINE variant(no_init) noexcept : type_index(detail::invalid_value)
+ {
+ }
// http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
template <typename T, typename Traits = detail::value_traits<T, Types...>,
typename Enable = typename std::enable_if<Traits::is_valid>::type>
- VARIANT_INLINE variant(T&& val) noexcept(std::is_nothrow_constructible<typename Traits::target_type, T&&>::value)
- : type_index(Traits::index)
+ VARIANT_INLINE variant(T&& val) noexcept(
+ std::is_nothrow_constructible<typename Traits::target_type,
+ T&&>::value) :
+ type_index(Traits::index)
{
new (&data) typename Traits::target_type(std::forward<T>(val));
}
- VARIANT_INLINE variant(variant<Types...> const& old)
- : type_index(old.type_index)
+ VARIANT_INLINE variant(variant<Types...> const& old) :
+ type_index(old.type_index)
{
helper_type::copy(old.type_index, &old.data, &data);
}
- VARIANT_INLINE variant(variant<Types...>&& old) noexcept(std::is_nothrow_move_constructible<std::tuple<Types...>>::value)
- : type_index(old.type_index)
+ VARIANT_INLINE variant(variant<Types...>&& old) noexcept(
+ std::is_nothrow_move_constructible<std::tuple<Types...>>::value) :
+ type_index(old.type_index)
{
helper_type::move(old.type_index, &old.data, &data);
}
-private:
+ private:
VARIANT_INLINE void copy_assign(variant<Types...> const& rhs)
{
helper_type::destroy(type_index, &data);
@@ -603,7 +667,7 @@
type_index = rhs.type_index;
}
-public:
+ public:
VARIANT_INLINE variant<Types...>& operator=(variant<Types...>&& other)
{
move_assign(std::move(other));
@@ -636,17 +700,21 @@
}
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE bool is() const
{
return type_index == detail::direct_type<T, Types...>::index;
}
- template <typename T,typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE bool is() const
{
- return type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index;
+ return type_index ==
+ detail::direct_type<recursive_wrapper<T>, Types...>::index;
}
VARIANT_INLINE bool valid() const
@@ -665,7 +733,8 @@
// get_unchecked<T>()
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get_unchecked()
{
return *reinterpret_cast<T*>(&data);
@@ -674,7 +743,8 @@
#ifdef HAS_EXCEPTIONS
// get<T>()
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get()
{
if (type_index == detail::direct_type<T, Types...>::index)
@@ -689,7 +759,8 @@
#endif
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get_unchecked() const
{
return *reinterpret_cast<T const*>(&data);
@@ -697,7 +768,8 @@
#ifdef HAS_EXCEPTIONS
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get() const
{
if (type_index == detail::direct_type<T, Types...>::index)
@@ -712,8 +784,10 @@
#endif
// get_unchecked<T>() - T stored as recursive_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get_unchecked()
{
return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
@@ -721,11 +795,14 @@
#ifdef HAS_EXCEPTIONS
// get<T>() - T stored as recursive_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get()
{
- if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+ if (type_index ==
+ detail::direct_type<recursive_wrapper<T>, Types...>::index)
{
return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
}
@@ -736,21 +813,27 @@
}
#endif
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get_unchecked() const
{
return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
}
#ifdef HAS_EXCEPTIONS
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get() const
{
- if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+ if (type_index ==
+ detail::direct_type<recursive_wrapper<T>, Types...>::index)
{
- return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
+ return (*reinterpret_cast<recursive_wrapper<T> const*>(&data))
+ .get();
}
else
{
@@ -760,8 +843,11 @@
#endif
// get_unchecked<T>() - T stored as std::reference_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <
+ typename T,
+ typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get_unchecked()
{
return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
@@ -769,11 +855,15 @@
#ifdef HAS_EXCEPTIONS
// get<T>() - T stored as std::reference_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <
+ typename T,
+ typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T>, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T& get()
{
- if (type_index == detail::direct_type<std::reference_wrapper<T>, Types...>::index)
+ if (type_index ==
+ detail::direct_type<std::reference_wrapper<T>, Types...>::index)
{
return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
}
@@ -784,21 +874,32 @@
}
#endif
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T const>,
+ Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get_unchecked() const
{
- return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
+ return (*reinterpret_cast<std::reference_wrapper<T const> const*>(
+ &data))
+ .get();
}
#ifdef HAS_EXCEPTIONS
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ template <typename T,
+ typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T const>,
+ Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE T const& get() const
{
- if (type_index == detail::direct_type<std::reference_wrapper<T const>, Types...>::index)
+ if (type_index == detail::direct_type<std::reference_wrapper<T const>,
+ Types...>::index)
{
- return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
+ return (*reinterpret_cast<std::reference_wrapper<T const> const*>(
+ &data))
+ .get();
}
else
{
@@ -816,46 +917,63 @@
VARIANT_INLINE int which() const noexcept
{
- return static_cast<int>(sizeof...(Types)-type_index - 1);
+ return static_cast<int>(sizeof...(Types) - type_index - 1);
}
template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ (detail::direct_type<T, Types...>::index !=
+ detail::invalid_value)>::type* = nullptr>
VARIANT_INLINE static constexpr int which() noexcept
{
- return static_cast<int>(sizeof...(Types)-detail::direct_type<T, Types...>::index - 1);
+ return static_cast<int>(sizeof...(Types) -
+ detail::direct_type<T, Types...>::index - 1);
}
// visitor
// unary
- template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
+ template <typename F, typename V,
+ typename R =
+ typename detail::result_of_unary_visit<F, first_type>::type>
auto VARIANT_INLINE static visit(V const& v, F&& f)
- -> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f)))
+ -> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(
+ v, std::forward<F>(f)))
{
- return detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+ return detail::dispatcher<F, V, R, Types...>::apply_const(
+ v, std::forward<F>(f));
}
// non-const
- template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
- auto VARIANT_INLINE static visit(V& v, F&& f)
- -> decltype(detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
+ template <typename F, typename V,
+ typename R =
+ typename detail::result_of_unary_visit<F, first_type>::type>
+ auto VARIANT_INLINE static visit(V& v, F&& f) -> decltype(
+ detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
{
- return detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
+ return detail::dispatcher<F, V, R, Types...>::apply(v,
+ std::forward<F>(f));
}
// binary
// const
- template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+ template <typename F, typename V,
+ typename R =
+ typename detail::result_of_binary_visit<F, first_type>::type>
auto VARIANT_INLINE static binary_visit(V const& v0, V const& v1, F&& f)
- -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f)))
+ -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(
+ v0, v1, std::forward<F>(f)))
{
- return detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ return detail::binary_dispatcher<F, V, R, Types...>::apply_const(
+ v0, v1, std::forward<F>(f));
}
// non-const
- template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+ template <typename F, typename V,
+ typename R =
+ typename detail::result_of_binary_visit<F, first_type>::type>
auto VARIANT_INLINE static binary_visit(V& v0, V& v1, F&& f)
- -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f)))
+ -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(
+ v0, v1, std::forward<F>(f)))
{
- return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+ return detail::binary_dispatcher<F, V, R, Types...>::apply(
+ v0, v1, std::forward<F>(f));
}
~variant() noexcept // no-throw destructor
@@ -909,14 +1027,16 @@
// unary visitor interface
// const
template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V const& v) -> decltype(V::visit(v, std::forward<F>(f)))
+auto VARIANT_INLINE apply_visitor(F&& f, V const& v)
+ -> decltype(V::visit(v, std::forward<F>(f)))
{
return V::visit(v, std::forward<F>(f));
}
// non-const
template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V& v) -> decltype(V::visit(v, std::forward<F>(f)))
+auto VARIANT_INLINE apply_visitor(F&& f, V& v)
+ -> decltype(V::visit(v, std::forward<F>(f)))
{
return V::visit(v, std::forward<F>(f));
}
@@ -924,37 +1044,38 @@
// binary visitor interface
// const
template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1)
+ -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
{
return V::binary_visit(v0, v1, std::forward<F>(f));
}
// non-const
template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1)
+ -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
{
return V::binary_visit(v0, v1, std::forward<F>(f));
}
-// getter interface
+ // getter interface
#ifdef HAS_EXCEPTIONS
template <typename ResultType, typename T>
-auto get(T& var)->decltype(var.template get<ResultType>())
+auto get(T& var) -> decltype(var.template get<ResultType>())
{
return var.template get<ResultType>();
}
#endif
-template <typename ResultType, typename T>
-ResultType& get_unchecked(T& var)
+template <typename ResultType, typename T> ResultType& get_unchecked(T& var)
{
return var.template get_unchecked<ResultType>();
}
#ifdef HAS_EXCEPTIONS
template <typename ResultType, typename T>
-auto get(T const& var)->decltype(var.template get<ResultType>())
+auto get(T const& var) -> decltype(var.template get<ResultType>())
{
return var.template get<ResultType>();
}
diff --git a/sdbusplus/bus/match.hpp b/sdbusplus/bus/match.hpp
index 62c0370..10cd679 100644
--- a/sdbusplus/bus/match.hpp
+++ b/sdbusplus/bus/match.hpp
@@ -41,8 +41,8 @@
* @param[in] context - An optional context to pass to the handler.
*/
match(sdbusplus::bus::bus& bus, const char* match,
- sd_bus_message_handler_t handler, void* context = nullptr)
- : _slot(nullptr)
+ sd_bus_message_handler_t handler, void* context = nullptr) :
+ _slot(nullptr)
{
sd_bus_slot* slot = nullptr;
sd_bus_add_match(bus.get(), &slot, match, handler, context);
@@ -50,8 +50,10 @@
_slot = decltype(_slot){slot};
}
match(sdbusplus::bus::bus& bus, const std::string& _match,
- sd_bus_message_handler_t handler, void* context = nullptr)
- : match(bus, _match.c_str(), handler, context) {}
+ sd_bus_message_handler_t handler, void* context = nullptr) :
+ match(bus, _match.c_str(), handler, context)
+ {
+ }
using callback_t = std::function<void(sdbusplus::message::message&)>;
@@ -61,10 +63,9 @@
* @param[in] match - The match to register.
* @param[in] callback - The callback for matches.
*/
- match(sdbusplus::bus::bus& bus, const char* match,
- callback_t callback)
- : _slot(nullptr),
- _callback(std::make_unique<callback_t>(std::move(callback)))
+ match(sdbusplus::bus::bus& bus, const char* match, callback_t callback) :
+ _slot(nullptr),
+ _callback(std::make_unique<callback_t>(std::move(callback)))
{
sd_bus_slot* slot = nullptr;
sd_bus_add_match(bus.get(), &slot, match, callCallback,
@@ -73,23 +74,24 @@
_slot = decltype(_slot){slot};
}
match(sdbusplus::bus::bus& bus, const std::string& _match,
- callback_t callback)
- : match(bus, _match.c_str(), callback) {}
+ callback_t callback) :
+ match(bus, _match.c_str(), callback)
+ {
+ }
- private:
- slot::slot _slot;
- std::unique_ptr<callback_t> _callback = nullptr;
+ private:
+ slot::slot _slot;
+ std::unique_ptr<callback_t> _callback = nullptr;
- static int callCallback(sd_bus_message *m, void* context,
- sd_bus_error* e)
- {
- auto c = static_cast<callback_t*>(context);
- message::message message{m};
+ static int callCallback(sd_bus_message* m, void* context, sd_bus_error* e)
+ {
+ auto c = static_cast<callback_t*>(context);
+ message::message message{m};
- (*c)(message);
+ (*c)(message);
- return 0;
- }
+ return 0;
+ }
};
/** Utilities for defining match rules based on the DBus specification */
@@ -101,29 +103,65 @@
namespace type
{
-inline auto signal() { return "type='signal',"s; }
-inline auto method() { return "type='method',"s; }
-inline auto method_return() { return "type='method_return',"s; }
-inline auto error() { return "type='error',"s; }
+inline auto signal()
+{
+ return "type='signal',"s;
+}
+inline auto method()
+{
+ return "type='method',"s;
+}
+inline auto method_return()
+{
+ return "type='method_return',"s;
+}
+inline auto error()
+{
+ return "type='error',"s;
+}
} // namespace type
-inline auto sender(const std::string& s) { return "sender='"s + s + "',"; }
+inline auto sender(const std::string& s)
+{
+ return "sender='"s + s + "',";
+}
inline auto interface(const std::string& s)
- { return "interface='"s + s + "',"; }
-inline auto member(const std::string& s) { return "member='"s + s + "',"; }
-inline auto path(const std::string& s) { return "path='"s + s + "',"; }
+{
+ return "interface='"s + s + "',";
+}
+inline auto member(const std::string& s)
+{
+ return "member='"s + s + "',";
+}
+inline auto path(const std::string& s)
+{
+ return "path='"s + s + "',";
+}
inline auto path_namespace(const std::string& s)
- { return "path_namespace='"s + s + "',"; }
+{
+ return "path_namespace='"s + s + "',";
+}
inline auto destination(const std::string& s)
- { return "destination='"s + s + "',"; }
+{
+ return "destination='"s + s + "',";
+}
inline auto argN(size_t n, const std::string& s)
- { return "arg"s + std::to_string(n) + "='"s + s + "',"; }
+{
+ return "arg"s + std::to_string(n) + "='"s + s + "',";
+}
inline auto argNpath(size_t n, const std::string& s)
- { return "arg"s + std::to_string(n) + "path='"s + s + "',"; }
+{
+ return "arg"s + std::to_string(n) + "path='"s + s + "',";
+}
inline auto arg0namespace(const std::string& s)
- { return "arg0namespace='"s + s + "',"; }
-inline auto eavesdrop() { return "eavesdrop='true',"s; }
+{
+ return "arg0namespace='"s + s + "',";
+}
+inline auto eavesdrop()
+{
+ return "eavesdrop='true',"s;
+}
inline auto nameOwnerChanged()
{
@@ -158,11 +196,8 @@
inline auto propertiesChanged(const std::string& p, const std::string& i)
{
- return type::signal() +
- path(p) +
- member("PropertiesChanged"s) +
- interface("org.freedesktop.DBus.Properties"s) +
- argN(0, i);
+ return type::signal() + path(p) + member("PropertiesChanged"s) +
+ interface("org.freedesktop.DBus.Properties"s) + argN(0, i);
}
/**
diff --git a/sdbusplus/message.hpp b/sdbusplus/message.hpp
index 21d3eb3..31ca95d 100644
--- a/sdbusplus/message.hpp
+++ b/sdbusplus/message.hpp
@@ -10,8 +10,11 @@
namespace sdbusplus
{
- // Forward declare sdbusplus::bus::bus for 'friend'ship.
-namespace bus { struct bus; };
+// Forward declare sdbusplus::bus::bus for 'friend'ship.
+namespace bus
+{
+struct bus;
+};
namespace message
{
@@ -41,14 +44,14 @@
*/
struct message
{
- /* Define all of the basic class operations:
- * Not allowed:
- * - Default constructor to avoid nullptrs.
- * - Copy operations due to internal unique_ptr.
- * Allowed:
- * - Move operations.
- * - Destructor.
- */
+ /* Define all of the basic class operations:
+ * Not allowed:
+ * - Default constructor to avoid nullptrs.
+ * - Copy operations due to internal unique_ptr.
+ * Allowed:
+ * - Move operations.
+ * - Destructor.
+ */
message() = delete;
message(const message&) = delete;
message& operator=(const message&) = delete;
@@ -61,27 +64,36 @@
* Takes increment ref-count of the msg-pointer and release when
* destructed.
*/
- explicit message(msgp_t m) : _msg(sd_bus_message_ref(m)) {}
+ explicit message(msgp_t m) : _msg(sd_bus_message_ref(m))
+ {
+ }
/** @brief Constructor for 'msgp_t'.
*
* Takes ownership of the msg-pointer and releases it when done.
*/
- message(msgp_t m, std::false_type) : _msg(m) {}
+ message(msgp_t m, std::false_type) : _msg(m)
+ {
+ }
/** @brief Release ownership of the stored msg-pointer. */
- msgp_t release() { return _msg.release(); }
+ msgp_t release()
+ {
+ return _msg.release();
+ }
/** @brief Check if message contains a real pointer. (non-nullptr). */
- explicit operator bool() const { return bool(_msg); }
-
+ explicit operator bool() const
+ {
+ return bool(_msg);
+ }
/** @brief Perform sd_bus_message_append, with automatic type deduction.
*
* @tparam ...Args - Type of items to append to message.
* @param[in] args - Items to append to message.
*/
- template <typename ...Args> void append(Args&&... args)
+ template <typename... Args> void append(Args&&... args)
{
sdbusplus::message::append(_msg.get(), std::forward<Args>(args)...);
}
@@ -91,7 +103,7 @@
* @tparam ...Args - Type of items to read from message.
* @param[out] args - Items to read from message.
*/
- template <typename ...Args> void read(Args&&... args)
+ template <typename... Args> void read(Args&&... args)
{
sdbusplus::message::read(_msg.get(), std::forward<Args>(args)...);
}
@@ -164,9 +176,9 @@
}
/** @brief Get the transaction cookie of a message.
- *
- * @return The transaction cookie of a message.
- */
+ *
+ * @return The transaction cookie of a message.
+ */
auto get_cookie()
{
uint64_t cookie;
@@ -216,14 +228,20 @@
}
/** @brief Perform a 'signal-send' call. */
- void signal_send() { method_return(); }
+ void signal_send()
+ {
+ method_return();
+ }
friend struct sdbusplus::bus::bus;
- private:
- /** @brief Get a pointer to the owned 'msgp_t'. */
- msgp_t get() { return _msg.get(); }
- details::msg _msg;
+ private:
+ /** @brief Get a pointer to the owned 'msgp_t'. */
+ msgp_t get()
+ {
+ return _msg.get();
+ }
+ details::msg _msg;
};
} // namespace message
diff --git a/sdbusplus/message/append.hpp b/sdbusplus/message/append.hpp
index 8818220..6558fd9 100644
--- a/sdbusplus/message/append.hpp
+++ b/sdbusplus/message/append.hpp
@@ -17,7 +17,7 @@
* (This is an empty no-op function that is useful in some cases for
* variadic template reasons.)
*/
-inline void append(sd_bus_message* m) {};
+inline void append(sd_bus_message* m){};
/** @brief Append data into an sdbus message.
*
* @param[in] msg - The message to append to.
@@ -29,7 +29,7 @@
* appropriate type parameters. It may also do conversions, where needed,
* to convert C++ types into C representations (eg. string, vector).
*/
-template <typename ...Args> void append(sd_bus_message* m, Args&&... args);
+template <typename... Args> void append(sd_bus_message* m, Args&&... args);
namespace details
{
@@ -44,30 +44,50 @@
* User-defined types are expected to inherit from std::false_type.
*
*/
-template<typename T> struct can_append_multiple : std::true_type {};
- // std::string needs a c_str() call.
-template<> struct can_append_multiple<std::string> : std::false_type {};
- // object_path needs a c_str() call.
-template<> struct can_append_multiple<object_path> : std::false_type {};
- // signature needs a c_str() call.
-template<> struct can_append_multiple<signature> : std::false_type {};
- // bool needs to be resized to int, per sdbus documentation.
-template<> struct can_append_multiple<bool> : std::false_type {};
- // std::vector needs a loop.
-template<typename T>
-struct can_append_multiple<std::vector<T>> : std::false_type {};
- // std::pair needs to be broken down into components.
-template<typename T1, typename T2>
-struct can_append_multiple<std::pair<T1,T2>> : std::false_type {};
- // std::map needs a loop.
-template<typename T1, typename T2>
-struct can_append_multiple<std::map<T1,T2>> : std::false_type {};
- // std::tuple needs to be broken down into components.
-template<typename ...Args>
-struct can_append_multiple<std::tuple<Args...>> : std::false_type {};
- // variant needs to be broken down into components.
-template<typename ...Args>
-struct can_append_multiple<variant<Args...>> : std::false_type {};
+template <typename T> struct can_append_multiple : std::true_type
+{
+};
+// std::string needs a c_str() call.
+template <> struct can_append_multiple<std::string> : std::false_type
+{
+};
+// object_path needs a c_str() call.
+template <> struct can_append_multiple<object_path> : std::false_type
+{
+};
+// signature needs a c_str() call.
+template <> struct can_append_multiple<signature> : std::false_type
+{
+};
+// bool needs to be resized to int, per sdbus documentation.
+template <> struct can_append_multiple<bool> : std::false_type
+{
+};
+// std::vector needs a loop.
+template <typename T>
+struct can_append_multiple<std::vector<T>> : std::false_type
+{
+};
+// std::pair needs to be broken down into components.
+template <typename T1, typename T2>
+struct can_append_multiple<std::pair<T1, T2>> : std::false_type
+{
+};
+// std::map needs a loop.
+template <typename T1, typename T2>
+struct can_append_multiple<std::map<T1, T2>> : std::false_type
+{
+};
+// std::tuple needs to be broken down into components.
+template <typename... Args>
+struct can_append_multiple<std::tuple<Args...>> : std::false_type
+{
+};
+// variant needs to be broken down into components.
+template <typename... Args>
+struct can_append_multiple<variant<Args...>> : std::false_type
+{
+};
/** @struct append_single
* @brief Utility to append a single C++ element into a sd_bus_message.
@@ -77,11 +97,10 @@
*
* @tparam S - Type of element to append.
*/
-template<typename S> struct append_single
+template <typename S> struct append_single
{
// Downcast
- template<typename T>
- using Td = types::details::type_id_downcast_t<T>;
+ template <typename T> using Td = types::details::type_id_downcast_t<T>;
// sd_bus_message_append_basic expects a T* (cast to void*) for most types,
// so t& is appropriate. In the case of char*, it expects the void* is
@@ -89,13 +108,16 @@
//
// Use these helper templates 'address_of(t)' in place of '&t' to
// handle both cases.
- template<typename T>
- static auto address_of_helper(T&& t, std::false_type) { return &t; }
- template<typename T>
- static auto address_of_helper(T&& t, std::true_type) { return t; }
+ template <typename T> static auto address_of_helper(T&& t, std::false_type)
+ {
+ return &t;
+ }
+ template <typename T> static auto address_of_helper(T&& t, std::true_type)
+ {
+ return t;
+ }
- template<typename T>
- static auto address_of(T&& t)
+ template <typename T> static auto address_of(T&& t)
{
return address_of_helper(std::forward<T>(t),
std::is_pointer<std::remove_reference_t<T>>());
@@ -114,14 +136,14 @@
* @param[in] m - sd_bus_message to append into.
* @param[in] t - The item to append.
*/
- template<typename T,
- typename = std::enable_if_t<std::is_same<S, Td<T>>::value>>
+ template <typename T,
+ typename = std::enable_if_t<std::is_same<S, Td<T>>::value>>
static void op(sd_bus_message* m, T&& t)
{
// For this default implementation, we need to ensure that only
// basic types are used.
static_assert(std::is_fundamental<Td<T>>::value ||
- std::is_convertible<Td<T>, const char*>::value,
+ std::is_convertible<Td<T>, const char*>::value,
"Non-basic types are not allowed.");
constexpr auto dbusType = std::get<0>(types::type_id<T>());
@@ -130,14 +152,13 @@
}
};
-template<typename T> using append_single_t =
- append_single<types::details::type_id_downcast_t<T>>;
+template <typename T>
+using append_single_t = append_single<types::details::type_id_downcast_t<T>>;
/** @brief Specialization of append_single for std::strings. */
template <> struct append_single<std::string>
{
- template<typename T>
- static void op(sd_bus_message* m, T&& s)
+ template <typename T> static void op(sd_bus_message* m, T&& s)
{
constexpr auto dbusType = std::get<0>(types::type_id<T>());
sd_bus_message_append_basic(m, dbusType, s.c_str());
@@ -147,20 +168,17 @@
/** @brief Specialization of append_single for details::string_wrapper. */
template <typename T> struct append_single<details::string_wrapper<T>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = std::get<0>(types::type_id<S>());
sd_bus_message_append_basic(m, dbusType, s.str.c_str());
}
};
-
/** @brief Specialization of append_single for bool. */
template <> struct append_single<bool>
{
- template<typename T>
- static void op(sd_bus_message* m, T&& b)
+ template <typename T> static void op(sd_bus_message* m, T&& b)
{
constexpr auto dbusType = std::get<0>(types::type_id<T>());
int i = b;
@@ -171,13 +189,15 @@
/** @brief Specialization of append_single for std::vectors. */
template <typename T> struct append_single<std::vector<T>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(types::type_id<T>());
sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());
- for(auto& i : s) { sdbusplus::message::append(m, i); }
+ for (auto& i : s)
+ {
+ sdbusplus::message::append(m, i);
+ }
sd_bus_message_close_container(m);
}
};
@@ -185,15 +205,13 @@
/** @brief Specialization of append_single for std::pairs. */
template <typename T1, typename T2> struct append_single<std::pair<T1, T2>>
{
- template <typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(
- std::tuple_cat(types::type_id_nonull<T1>(),
- types::type_id<T2>()));
+ std::tuple_cat(types::type_id_nonull<T1>(), types::type_id<T2>()));
- sd_bus_message_open_container(
- m, SD_BUS_TYPE_DICT_ENTRY, dbusType.data());
+ sd_bus_message_open_container(m, SD_BUS_TYPE_DICT_ENTRY,
+ dbusType.data());
sdbusplus::message::append(m, s.first, s.second);
sd_bus_message_close_container(m);
}
@@ -202,63 +220,57 @@
/** @brief Specialization of append_single for std::maps. */
template <typename T1, typename T2> struct append_single<std::map<T1, T2>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(
- types::type_id<typename std::map<T1, T2>::value_type>());
+ types::type_id<typename std::map<T1, T2>::value_type>());
sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());
- for(auto& i : s) { sdbusplus::message::append(m, i); }
+ for (auto& i : s)
+ {
+ sdbusplus::message::append(m, i);
+ }
sd_bus_message_close_container(m);
}
};
/** @brief Specialization of append_single for std::tuples. */
-template <typename ...Args> struct append_single<std::tuple<Args...>>
+template <typename... Args> struct append_single<std::tuple<Args...>>
{
- template<typename S, std::size_t... I>
+ template <typename S, std::size_t... I>
static void _op(sd_bus_message* m, S&& s,
std::integer_sequence<std::size_t, I...>)
{
sdbusplus::message::append(m, std::get<I>(s)...);
}
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(std::tuple_cat(
- types::type_id_nonull<Args...>(),
- std::make_tuple('\0') /* null terminator for C-string */));
+ types::type_id_nonull<Args...>(),
+ std::make_tuple('\0') /* null terminator for C-string */));
- sd_bus_message_open_container(
- m, SD_BUS_TYPE_STRUCT, dbusType.data());
- _op(m, std::forward<S>(s),
- std::make_index_sequence<sizeof...(Args)>());
+ sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, dbusType.data());
+ _op(m, std::forward<S>(s), std::make_index_sequence<sizeof...(Args)>());
sd_bus_message_close_container(m);
-
}
};
/** @brief Specialization of append_single for std::variant. */
-template <typename ...Args> struct append_single<variant<Args...>>
+template <typename... Args> struct append_single<variant<Args...>>
{
- template<typename S,
- typename = std::enable_if_t<0 < sizeof...(Args)>>
+ template <typename S, typename = std::enable_if_t<0 < sizeof...(Args)>>
static void op(sd_bus_message* m, S&& s)
{
- auto apply =
- [m](auto&& arg)
- {
- constexpr auto dbusType = utility::tuple_to_array(
- types::type_id<decltype(arg)>());
+ auto apply = [m](auto&& arg) {
+ constexpr auto dbusType =
+ utility::tuple_to_array(types::type_id<decltype(arg)>());
- sd_bus_message_open_container(m,
- SD_BUS_TYPE_VARIANT,
- dbusType.data());
- sdbusplus::message::append(m, arg);
- sd_bus_message_close_container(m);
- };
+ sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT,
+ dbusType.data());
+ sdbusplus::message::append(m, arg);
+ sd_bus_message_close_container(m);
+ };
std::remove_reference_t<S>::visit(s, apply);
}
@@ -274,8 +286,8 @@
template <typename Tuple, size_t... I>
void append_tuple(sd_bus_message* m, Tuple&& t, std::index_sequence<I...>)
{
- auto dbusTypes = utility::tuple_to_array(
- types::type_id<decltype(std::get<I>(t))...>());
+ auto dbusTypes =
+ utility::tuple_to_array(types::type_id<decltype(std::get<I>(t))...>());
sd_bus_message_append(m, dbusTypes.data(), std::get<I>(t)...);
}
@@ -288,7 +300,8 @@
* A tuple of 2 or more entries can be added as a set with
* sd_bus_message_append.
*/
-template <typename Tuple> std::enable_if_t<2 <= std::tuple_size<Tuple>::value>
+template <typename Tuple>
+std::enable_if_t<2 <= std::tuple_size<Tuple>::value>
append_tuple(sd_bus_message* m, Tuple&& t)
{
append_tuple(m, std::move(t),
@@ -305,7 +318,8 @@
* Note: Some 1-entry tuples may need special handling due to
* can_append_multiple::value == false.
*/
-template <typename Tuple> std::enable_if_t<1 == std::tuple_size<Tuple>::value>
+template <typename Tuple>
+std::enable_if_t<1 == std::tuple_size<Tuple>::value>
append_tuple(sd_bus_message* m, Tuple&& t)
{
using itemType = decltype(std::get<0>(t));
@@ -316,8 +330,11 @@
*
* This a no-op function that is useful due to variadic templates.
*/
-template <typename Tuple> std::enable_if_t<0 == std::tuple_size<Tuple>::value>
-inline append_tuple(sd_bus_message* m, Tuple&& t) {}
+template <typename Tuple>
+std::enable_if_t<0 == std::tuple_size<Tuple>::value> inline append_tuple(
+ sd_bus_message* m, Tuple&& t)
+{
+}
/** @brief Group a sequence of C++ types for appending into an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -325,8 +342,9 @@
*
* Specialization for when can_append_multiple<Arg> is true.
*/
-template <typename Tuple, typename Arg> std::enable_if_t<
- can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for appending into an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -334,8 +352,9 @@
*
* Specialization for when can_append_multiple<Arg> is false.
*/
-template <typename Tuple, typename Arg> std::enable_if_t<
- !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for appending into an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -344,8 +363,9 @@
*
* Specialization for when can_append_multiple<Arg> is true.
*/
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);
/** @brief Group a sequence of C++ types for appending into an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -354,24 +374,27 @@
*
* Specialization for when can_append_multiple<Arg> is false.
*/
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);
-template <typename Tuple, typename Arg> std::enable_if_t<
- can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
// Last element of a sequence and can_append_multiple, so add it to
// the tuple and call append_tuple.
- append_tuple(m, std::tuple_cat(std::forward<Tuple>(t),
- std::forward_as_tuple(
- std::forward<Arg>(arg))));
+ append_tuple(m,
+ std::tuple_cat(std::forward<Tuple>(t),
+ std::forward_as_tuple(std::forward<Arg>(arg))));
}
-template <typename Tuple, typename Arg> std::enable_if_t<
- !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
// Last element of a sequence but !can_append_multiple, so call
@@ -382,21 +405,24 @@
append_tuple(m, std::forward_as_tuple(std::forward<Arg>(arg)));
}
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
// Not the last element of a sequence and can_append_multiple, so add it
// to the tuple and keep grouping.
- append_grouping(m, std::tuple_cat(std::forward<Tuple>(t),
- std::forward_as_tuple(
- std::forward<Arg>(arg))),
- std::forward<Rest>(rest)...);
+ append_grouping(
+ m,
+ std::tuple_cat(std::forward<Tuple>(t),
+ std::forward_as_tuple(std::forward<Arg>(arg))),
+ std::forward<Rest>(rest)...);
}
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ !can_append_multiple<types::details::type_id_downcast_t<Arg>>::value>
append_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
// Not the last element of a sequence but !can_append_multiple, so call
@@ -410,7 +436,7 @@
} // namespace details
-template <typename ...Args> void append(sd_bus_message* m, Args&&... args)
+template <typename... Args> void append(sd_bus_message* m, Args&&... args)
{
details::append_grouping(m, std::make_tuple(), std::forward<Args>(args)...);
}
diff --git a/sdbusplus/message/native_types.hpp b/sdbusplus/message/native_types.hpp
index ce50f8e..11a4b23 100644
--- a/sdbusplus/message/native_types.hpp
+++ b/sdbusplus/message/native_types.hpp
@@ -13,8 +13,7 @@
/** Simple wrapper class for std::string to allow conversion to and from an
* alternative typename. */
-template <typename T>
-struct string_wrapper
+template <typename T> struct string_wrapper
{
std::string str;
@@ -25,17 +24,42 @@
string_wrapper& operator=(string_wrapper&&) = default;
~string_wrapper() = default;
- string_wrapper(const std::string& str) : str(str) {}
- string_wrapper(std::string&& str) : str(std::move(str)) {}
+ string_wrapper(const std::string& str) : str(str)
+ {
+ }
+ string_wrapper(std::string&& str) : str(std::move(str))
+ {
+ }
- operator std::string() const { return str; }
- operator const std::string&() const { return str; }
- operator std::string&&() { return std::move(str); }
+ operator std::string() const
+ {
+ return str;
+ }
+ operator const std::string&() const
+ {
+ return str;
+ }
+ operator std::string &&()
+ {
+ return std::move(str);
+ }
- bool operator==(const string_wrapper<T>& r) const { return str == r.str; }
- bool operator<(const string_wrapper<T>& r) const { return str < r.str; }
- bool operator==(const std::string& r) const { return str == r; }
- bool operator<(const std::string& r) const { return str < r; }
+ bool operator==(const string_wrapper<T>& r) const
+ {
+ return str == r.str;
+ }
+ bool operator<(const string_wrapper<T>& r) const
+ {
+ return str < r.str;
+ }
+ bool operator==(const std::string& r) const
+ {
+ return str == r;
+ }
+ bool operator<(const std::string& r) const
+ {
+ return str < r;
+ }
friend bool operator==(const std::string& l, const string_wrapper& r)
{
@@ -48,9 +72,13 @@
};
/** Typename for sdbus OBJECT_PATH types. */
-struct object_path_type {};
+struct object_path_type
+{
+};
/** Typename for sdbus SIGNATURE types. */
-struct signature_type {};
+struct signature_type
+{
+};
} // namespace details
diff --git a/sdbusplus/message/read.hpp b/sdbusplus/message/read.hpp
index f7ab4d3..31fd594 100644
--- a/sdbusplus/message/read.hpp
+++ b/sdbusplus/message/read.hpp
@@ -17,7 +17,7 @@
* (This is an empty no-op function that is useful in some cases for
* variadic template reasons.)
*/
-inline void read(sd_bus_message* m) {};
+inline void read(sd_bus_message* m){};
/** @brief Read data from an sdbus message.
*
* @param[in] msg - The message to read from.
@@ -29,7 +29,7 @@
* appropriate type parameters. It may also do conversions, where needed,
* to convert C++ types into C representations (eg. string, vector).
*/
-template <typename ...Args> void read(sd_bus_message* m, Args&&... args);
+template <typename... Args> void read(sd_bus_message* m, Args&&... args);
namespace details
{
@@ -44,30 +44,49 @@
* User-defined types are expected to inherit from std::false_type.
*
*/
-template<typename T> struct can_read_multiple : std::true_type {};
- // std::string needs a char* conversion.
-template<> struct can_read_multiple<std::string> : std::false_type {};
- // object_path needs a char* conversion.
-template<> struct can_read_multiple<object_path> : std::false_type {};
- // signature needs a char* conversion.
-template<> struct can_read_multiple<signature> : std::false_type {};
- // bool needs to be resized to int, per sdbus documentation.
-template<> struct can_read_multiple<bool> : std::false_type {};
- // std::vector needs a loop.
-template<typename T>
-struct can_read_multiple<std::vector<T>> : std::false_type {};
- // std::pair needs to be broken down into components.
-template<typename T1, typename T2>
-struct can_read_multiple<std::pair<T1,T2>> : std::false_type {};
- // std::map needs a loop.
-template<typename T1, typename T2>
-struct can_read_multiple<std::map<T1,T2>> : std::false_type {};
- // std::tuple needs to be broken down into components.
-template<typename ...Args>
-struct can_read_multiple<std::tuple<Args...>> : std::false_type {};
- // variant needs to be broken down into components.
-template<typename ...Args>
-struct can_read_multiple<variant<Args...>> : std::false_type {};
+template <typename T> struct can_read_multiple : std::true_type
+{
+};
+// std::string needs a char* conversion.
+template <> struct can_read_multiple<std::string> : std::false_type
+{
+};
+// object_path needs a char* conversion.
+template <> struct can_read_multiple<object_path> : std::false_type
+{
+};
+// signature needs a char* conversion.
+template <> struct can_read_multiple<signature> : std::false_type
+{
+};
+// bool needs to be resized to int, per sdbus documentation.
+template <> struct can_read_multiple<bool> : std::false_type
+{
+};
+// std::vector needs a loop.
+template <typename T> struct can_read_multiple<std::vector<T>> : std::false_type
+{
+};
+// std::pair needs to be broken down into components.
+template <typename T1, typename T2>
+struct can_read_multiple<std::pair<T1, T2>> : std::false_type
+{
+};
+// std::map needs a loop.
+template <typename T1, typename T2>
+struct can_read_multiple<std::map<T1, T2>> : std::false_type
+{
+};
+// std::tuple needs to be broken down into components.
+template <typename... Args>
+struct can_read_multiple<std::tuple<Args...>> : std::false_type
+{
+};
+// variant needs to be broken down into components.
+template <typename... Args>
+struct can_read_multiple<variant<Args...>> : std::false_type
+{
+};
/** @struct read_single
* @brief Utility to read a single C++ element from a sd_bus_message.
@@ -77,11 +96,10 @@
*
* @tparam S - Type of element to read.
*/
-template<typename S> struct read_single
+template <typename S> struct read_single
{
// Downcast
- template<typename T>
- using Td = types::details::type_id_downcast_t<T>;
+ template <typename T> using Td = types::details::type_id_downcast_t<T>;
/** @brief Do the operation to read element.
*
@@ -96,14 +114,14 @@
* @param[in] m - sd_bus_message to read from.
* @param[out] t - The reference to read item into.
*/
- template<typename T,
- typename = std::enable_if_t<std::is_same<S, Td<T>>::value>>
+ template <typename T,
+ typename = std::enable_if_t<std::is_same<S, Td<T>>::value>>
static void op(sd_bus_message* m, T&& t)
{
// For this default implementation, we need to ensure that only
// basic types are used.
static_assert(std::is_fundamental<Td<T>>::value ||
- std::is_convertible<Td<T>, const char*>::value,
+ std::is_convertible<Td<T>, const char*>::value,
"Non-basic types are not allowed.");
constexpr auto dbusType = std::get<0>(types::type_id<T>());
@@ -111,14 +129,13 @@
}
};
-template<typename T> using read_single_t =
- read_single<types::details::type_id_downcast_t<T>>;
+template <typename T>
+using read_single_t = read_single<types::details::type_id_downcast_t<T>>;
/** @brief Specialization of read_single for std::strings. */
template <> struct read_single<std::string>
{
- template<typename T>
- static void op(sd_bus_message* m, T&& s)
+ template <typename T> static void op(sd_bus_message* m, T&& s)
{
constexpr auto dbusType = std::get<0>(types::type_id<T>());
const char* str = nullptr;
@@ -130,8 +147,7 @@
/** @brief Specialization of read_single for details::string_wrapper. */
template <typename T> struct read_single<details::string_wrapper<T>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = std::get<0>(types::type_id<S>());
const char* str = nullptr;
@@ -140,12 +156,10 @@
}
};
-
/** @brief Specialization of read_single for bools. */
template <> struct read_single<bool>
{
- template<typename T>
- static void op(sd_bus_message* m, T&& b)
+ template <typename T> static void op(sd_bus_message* m, T&& b)
{
constexpr auto dbusType = std::get<0>(types::type_id<T>());
int i = 0;
@@ -154,19 +168,17 @@
}
};
-
/** @brief Specialization of read_single for std::vectors. */
template <typename T> struct read_single<std::vector<T>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
s.clear();
constexpr auto dbusType = utility::tuple_to_array(types::type_id<T>());
sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());
- while(!sd_bus_message_at_end(m, false))
+ while (!sd_bus_message_at_end(m, false))
{
std::remove_const_t<T> t{};
sdbusplus::message::read(m, t);
@@ -180,15 +192,13 @@
/** @brief Specialization of read_single for std::pairs. */
template <typename T1, typename T2> struct read_single<std::pair<T1, T2>>
{
- template <typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(
- std::tuple_cat(types::type_id_nonull<T1>(),
- types::type_id<T2>()));
+ std::tuple_cat(types::type_id_nonull<T1>(), types::type_id<T2>()));
- sd_bus_message_enter_container(
- m, SD_BUS_TYPE_DICT_ENTRY, dbusType.data());
+ sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
+ dbusType.data());
sdbusplus::message::read(m, s.first, s.second);
sd_bus_message_exit_container(m);
}
@@ -197,17 +207,16 @@
/** @brief Specialization of read_single for std::maps. */
template <typename T1, typename T2> struct read_single<std::map<T1, T2>>
{
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
s.clear();
constexpr auto dbusType = utility::tuple_to_array(
- types::type_id<typename std::map<T1, T2>::value_type>());
+ types::type_id<typename std::map<T1, T2>::value_type>());
sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());
- while(!sd_bus_message_at_end(m, false))
+ while (!sd_bus_message_at_end(m, false))
{
std::pair<std::remove_const_t<T1>, std::remove_const_t<T2>> p{};
sdbusplus::message::read(m, p);
@@ -219,42 +228,37 @@
};
/** @brief Specialization of read_single for std::tuples. */
-template <typename ...Args> struct read_single<std::tuple<Args...>>
+template <typename... Args> struct read_single<std::tuple<Args...>>
{
- template<typename S, std::size_t... I>
+ template <typename S, std::size_t... I>
static void _op(sd_bus_message* m, S&& s,
std::integer_sequence<std::size_t, I...>)
{
sdbusplus::message::read(m, std::get<I>(s)...);
}
- template<typename S>
- static void op(sd_bus_message* m, S&& s)
+ template <typename S> static void op(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(std::tuple_cat(
- types::type_id_nonull<Args...>(),
- std::make_tuple('\0') /* null terminator for C-string */));
+ types::type_id_nonull<Args...>(),
+ std::make_tuple('\0') /* null terminator for C-string */));
- sd_bus_message_enter_container(
- m, SD_BUS_TYPE_STRUCT, dbusType.data());
- _op(m, std::forward<S>(s),
- std::make_index_sequence<sizeof...(Args)>());
+ sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, dbusType.data());
+ _op(m, std::forward<S>(s), std::make_index_sequence<sizeof...(Args)>());
sd_bus_message_exit_container(m);
-
}
};
/** @brief Specialization of read_single for std::variant. */
-template <typename ...Args> struct read_single<variant<Args...>>
+template <typename... Args> struct read_single<variant<Args...>>
{
- template<typename S, typename S1, typename ...Args1>
+ template <typename S, typename S1, typename... Args1>
static void read(sd_bus_message* m, S&& s)
{
constexpr auto dbusType = utility::tuple_to_array(types::type_id<S1>());
- auto rc = sd_bus_message_verify_type(m,
- SD_BUS_TYPE_VARIANT,
- dbusType.data());
+ auto rc =
+ sd_bus_message_verify_type(m, SD_BUS_TYPE_VARIANT, dbusType.data());
if (0 >= rc)
{
read<S, Args1...>(m, s);
@@ -270,15 +274,13 @@
s = std::move(s1);
}
- template<typename S>
- static void read(sd_bus_message* m, S&& s)
+ template <typename S> static void read(sd_bus_message* m, S&& s)
{
sd_bus_message_skip(m, "v");
s = std::remove_reference_t<S>{};
}
- template<typename S,
- typename = std::enable_if_t<0 < sizeof...(Args)>>
+ template <typename S, typename = std::enable_if_t<0 < sizeof...(Args)>>
static void op(sd_bus_message* m, S&& s)
{
read<S, Args...>(m, s);
@@ -295,8 +297,8 @@
template <typename Tuple, size_t... I>
void read_tuple(sd_bus_message* m, Tuple&& t, std::index_sequence<I...>)
{
- auto dbusTypes = utility::tuple_to_array(
- types::type_id<decltype(std::get<I>(t))...>());
+ auto dbusTypes =
+ utility::tuple_to_array(types::type_id<decltype(std::get<I>(t))...>());
sd_bus_message_read(m, dbusTypes.data(), &std::get<I>(t)...);
}
@@ -309,7 +311,8 @@
* A tuple of 2 or more entries can be read as a set with
* sd_bus_message_read.
*/
-template <typename Tuple> std::enable_if_t<2 <= std::tuple_size<Tuple>::value>
+template <typename Tuple>
+std::enable_if_t<2 <= std::tuple_size<Tuple>::value>
read_tuple(sd_bus_message* m, Tuple&& t)
{
read_tuple(m, std::move(t),
@@ -326,7 +329,8 @@
* Note: Some 1-entry tuples may need special handling due to
* can_read_multiple::value == false.
*/
-template <typename Tuple> std::enable_if_t<1 == std::tuple_size<Tuple>::value>
+template <typename Tuple>
+std::enable_if_t<1 == std::tuple_size<Tuple>::value>
read_tuple(sd_bus_message* m, Tuple&& t)
{
using itemType = decltype(std::get<0>(t));
@@ -337,8 +341,11 @@
*
* This a no-op function that is useful due to variadic templates.
*/
-template <typename Tuple> std::enable_if_t<0 == std::tuple_size<Tuple>::value>
-inline read_tuple(sd_bus_message* m, Tuple&& t) {}
+template <typename Tuple>
+std::enable_if_t<0 == std::tuple_size<Tuple>::value> inline read_tuple(
+ sd_bus_message* m, Tuple&& t)
+{
+}
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -346,8 +353,9 @@
*
* Specialization for when can_read_multiple<Arg> is true.
*/
-template <typename Tuple, typename Arg> std::enable_if_t<
- can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -355,8 +363,9 @@
*
* Specialization for when can_read_multiple<Arg> is false.
*/
-template <typename Tuple, typename Arg> std::enable_if_t<
- !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -365,8 +374,9 @@
*
* Specialization for when can_read_multiple<Arg> is true.
*/
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
* @tparam Tuple - A tuple of previously analyzed types.
@@ -375,24 +385,27 @@
*
* Specialization for when can_read_multiple<Arg> is false.
*/
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);
-template <typename Tuple, typename Arg> std::enable_if_t<
- can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
// Last element of a sequence and can_read_multiple, so add it to
// the tuple and call read_tuple.
- read_tuple(m, std::tuple_cat(std::forward<Tuple>(t),
- std::forward_as_tuple(
- std::forward<Arg>(arg))));
+ read_tuple(m,
+ std::tuple_cat(std::forward<Tuple>(t),
+ std::forward_as_tuple(std::forward<Arg>(arg))));
}
-template <typename Tuple, typename Arg> std::enable_if_t<
- !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg>
+std::enable_if_t<
+ !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
// Last element of a sequence but !can_read_multiple, so call
@@ -403,21 +416,23 @@
read_tuple(m, std::forward_as_tuple(std::forward<Arg>(arg)));
}
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
// Not the last element of a sequence and can_read_multiple, so add it
// to the tuple and keep grouping.
- read_grouping(m, std::tuple_cat(std::forward<Tuple>(t),
- std::forward_as_tuple(
- std::forward<Arg>(arg))),
+ read_grouping(m,
+ std::tuple_cat(std::forward<Tuple>(t),
+ std::forward_as_tuple(std::forward<Arg>(arg))),
std::forward<Rest>(rest)...);
}
-template <typename Tuple, typename Arg, typename ...Rest> std::enable_if_t<
- !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
+template <typename Tuple, typename Arg, typename... Rest>
+std::enable_if_t<
+ !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
// Not the last element of a sequence but !can_read_multiple, so call
@@ -431,7 +446,7 @@
} // namespace details
-template <typename ...Args> void read(sd_bus_message* m, Args&&... args)
+template <typename... Args> void read(sd_bus_message* m, Args&&... args)
{
details::read_grouping(m, std::make_tuple(), std::forward<Args>(args)...);
}
diff --git a/sdbusplus/message/types.hpp b/sdbusplus/message/types.hpp
index a65bc31..8dccbef 100644
--- a/sdbusplus/message/types.hpp
+++ b/sdbusplus/message/types.hpp
@@ -18,9 +18,7 @@
namespace variant_ns = mapbox::util;
-template <typename ...Args>
-using variant = variant_ns::variant<Args...>;
-
+template <typename... Args> using variant = variant_ns::variant<Args...>;
namespace types
{
@@ -39,13 +37,13 @@
* options at compile-time the use of type-deduced dbus strings is equal to
* the cost of hard-coded type string constants.
*/
-template <typename ...Args> constexpr auto type_id();
+template <typename... Args> constexpr auto type_id();
/** @fn type_id_nonull()
* @brief A non-null-terminated version of type_id.
*
* This is useful when type-ids may need to be concatenated.
*/
-template <typename ...Args> constexpr auto type_id_nonull();
+template <typename... Args> constexpr auto type_id_nonull();
namespace details
{
@@ -62,11 +60,11 @@
template <typename T> struct type_id_downcast
{
using type = typename utility::array_to_ptr_t<
- char, std::remove_cv_t<std::remove_reference_t<T>>>;
+ char, std::remove_cv_t<std::remove_reference_t<T>>>;
};
-template <typename T> using type_id_downcast_t =
- typename type_id_downcast<T>::type;
+template <typename T>
+using type_id_downcast_t = typename type_id_downcast<T>::type;
/** @struct undefined_type_id
* @brief Special type indicating no dbus-type_id is defined for a C++ type.
@@ -93,10 +91,10 @@
template <char C1, char... C> struct tuple_type_id
{
- /* This version check is required because a fix for auto is in 5.2+.
- * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66421
- */
- /** A tuple containing the type-characters. */
+/* This version check is required because a fix for auto is in 5.2+.
+ * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66421
+ */
+/** A tuple containing the type-characters. */
#if (__GNUC__ > 5) || (__GNUC__ == 5 && (__GNUC_MINOR__ >= 2))
static constexpr auto value = std::make_tuple(C1, C...);
#else
@@ -119,7 +117,7 @@
* @tparam T - The first type to get the dbus type character(s) for.
* @tparam ...Args - The remaining types.
*/
-template <typename T, typename ...Args> constexpr auto type_id_multiple();
+template <typename T, typename... Args> constexpr auto type_id_multiple();
/** @struct type_id
* @brief Defined dbus type tuple for a C++ type.
@@ -129,84 +127,113 @@
* Struct must have a 'value' tuple containing the dbus type. The default
* value is an empty tuple, which is used to indicate an unsupported type.
*/
-template <typename T> struct type_id : public undefined_type_id {};
- // Specializations for built-in types.
-template <> struct type_id<bool> : tuple_type_id<SD_BUS_TYPE_BOOLEAN> {};
-template <> struct type_id<uint8_t> : tuple_type_id<SD_BUS_TYPE_BYTE> {};
+template <typename T> struct type_id : public undefined_type_id
+{
+};
+// Specializations for built-in types.
+template <> struct type_id<bool> : tuple_type_id<SD_BUS_TYPE_BOOLEAN>
+{
+};
+template <> struct type_id<uint8_t> : tuple_type_id<SD_BUS_TYPE_BYTE>
+{
+};
// int8_t isn't supported by dbus.
-template <> struct type_id<uint16_t> : tuple_type_id<SD_BUS_TYPE_UINT16> {};
-template <> struct type_id<int16_t> : tuple_type_id<SD_BUS_TYPE_INT16> {};
-template <> struct type_id<uint32_t> : tuple_type_id<SD_BUS_TYPE_UINT32> {};
-template <> struct type_id<int32_t> : tuple_type_id<SD_BUS_TYPE_INT32> {};
-template <> struct type_id<uint64_t> : tuple_type_id<SD_BUS_TYPE_UINT64> {};
-template <> struct type_id<int64_t> : tuple_type_id<SD_BUS_TYPE_INT64> {};
+template <> struct type_id<uint16_t> : tuple_type_id<SD_BUS_TYPE_UINT16>
+{
+};
+template <> struct type_id<int16_t> : tuple_type_id<SD_BUS_TYPE_INT16>
+{
+};
+template <> struct type_id<uint32_t> : tuple_type_id<SD_BUS_TYPE_UINT32>
+{
+};
+template <> struct type_id<int32_t> : tuple_type_id<SD_BUS_TYPE_INT32>
+{
+};
+template <> struct type_id<uint64_t> : tuple_type_id<SD_BUS_TYPE_UINT64>
+{
+};
+template <> struct type_id<int64_t> : tuple_type_id<SD_BUS_TYPE_INT64>
+{
+};
// float isn't supported by dbus.
-template <> struct type_id<double> : tuple_type_id<SD_BUS_TYPE_DOUBLE> {};
-template <> struct type_id<const char*> : tuple_type_id<SD_BUS_TYPE_STRING> {};
-template <> struct type_id<char*> : tuple_type_id<SD_BUS_TYPE_STRING> {};
-template <> struct type_id<std::string> : tuple_type_id<SD_BUS_TYPE_STRING> {};
-template <> struct type_id<object_path> :
- tuple_type_id<SD_BUS_TYPE_OBJECT_PATH> {};
-template <> struct type_id<signature> :
- tuple_type_id<SD_BUS_TYPE_SIGNATURE> {};
+template <> struct type_id<double> : tuple_type_id<SD_BUS_TYPE_DOUBLE>
+{
+};
+template <> struct type_id<const char*> : tuple_type_id<SD_BUS_TYPE_STRING>
+{
+};
+template <> struct type_id<char*> : tuple_type_id<SD_BUS_TYPE_STRING>
+{
+};
+template <> struct type_id<std::string> : tuple_type_id<SD_BUS_TYPE_STRING>
+{
+};
+template <> struct type_id<object_path> : tuple_type_id<SD_BUS_TYPE_OBJECT_PATH>
+{
+};
+template <> struct type_id<signature> : tuple_type_id<SD_BUS_TYPE_SIGNATURE>
+{
+};
template <typename T> struct type_id<std::vector<T>>
{
- static constexpr auto value = std::tuple_cat(
- tuple_type_id<SD_BUS_TYPE_ARRAY>::value,
- type_id<type_id_downcast_t<T>>::value);
+ static constexpr auto value =
+ std::tuple_cat(tuple_type_id<SD_BUS_TYPE_ARRAY>::value,
+ type_id<type_id_downcast_t<T>>::value);
};
template <typename T1, typename T2> struct type_id<std::pair<T1, T2>>
{
- static constexpr auto value = std::tuple_cat(
- tuple_type_id<SD_BUS_TYPE_DICT_ENTRY_BEGIN>::value,
- type_id<type_id_downcast_t<T1>>::value,
- type_id<type_id_downcast_t<T2>>::value,
- tuple_type_id<SD_BUS_TYPE_DICT_ENTRY_END>::value);
+ static constexpr auto value =
+ std::tuple_cat(tuple_type_id<SD_BUS_TYPE_DICT_ENTRY_BEGIN>::value,
+ type_id<type_id_downcast_t<T1>>::value,
+ type_id<type_id_downcast_t<T2>>::value,
+ tuple_type_id<SD_BUS_TYPE_DICT_ENTRY_END>::value);
};
template <typename T1, typename T2> struct type_id<std::map<T1, T2>>
{
- static constexpr auto value = std::tuple_cat(
- tuple_type_id<SD_BUS_TYPE_ARRAY>::value,
- type_id<typename std::map<T1,T2>::value_type>::value);
+ static constexpr auto value =
+ std::tuple_cat(tuple_type_id<SD_BUS_TYPE_ARRAY>::value,
+ type_id<typename std::map<T1, T2>::value_type>::value);
};
-template <typename ...Args> struct type_id<std::tuple<Args...>>
+template <typename... Args> struct type_id<std::tuple<Args...>>
{
- static constexpr auto value = std::tuple_cat(
- tuple_type_id<SD_BUS_TYPE_STRUCT_BEGIN>::value,
- type_id<type_id_downcast_t<Args>>::value...,
- tuple_type_id<SD_BUS_TYPE_STRUCT_END>::value);
+ static constexpr auto value =
+ std::tuple_cat(tuple_type_id<SD_BUS_TYPE_STRUCT_BEGIN>::value,
+ type_id<type_id_downcast_t<Args>>::value...,
+ tuple_type_id<SD_BUS_TYPE_STRUCT_END>::value);
};
-template <typename ...Args>
-struct type_id<variant<Args...>> : tuple_type_id<SD_BUS_TYPE_VARIANT> {};
+template <typename... Args>
+struct type_id<variant<Args...>> : tuple_type_id<SD_BUS_TYPE_VARIANT>
+{
+};
template <typename T> constexpr auto& type_id_single()
{
static_assert(!std::is_base_of<undefined_type_id, type_id<T>>::value,
- "No dbus type conversion provided for type.");
+ "No dbus type conversion provided for type.");
return type_id<T>::value;
}
-template <typename T, typename ...Args> constexpr auto type_id_multiple()
+template <typename T, typename... Args> constexpr auto type_id_multiple()
{
- return std::tuple_cat(type_id_single<T>(),
- type_id_single<Args>()...);
+ return std::tuple_cat(type_id_single<T>(), type_id_single<Args>()...);
}
} // namespace details
-template <typename ...Args> constexpr auto type_id()
+template <typename... Args> constexpr auto type_id()
{
return std::tuple_cat(
details::type_id_multiple<details::type_id_downcast_t<Args>...>(),
- std::make_tuple('\0') /* null terminator for C-string */ );
+ std::make_tuple('\0') /* null terminator for C-string */);
}
-template <typename ...Args> constexpr auto type_id_nonull()
+template <typename... Args> constexpr auto type_id_nonull()
{
return details::type_id_multiple<details::type_id_downcast_t<Args>...>();
}
diff --git a/sdbusplus/server/bindings.hpp b/sdbusplus/server/bindings.hpp
index 88b0610..9d67ae3 100644
--- a/sdbusplus/server/bindings.hpp
+++ b/sdbusplus/server/bindings.hpp
@@ -17,12 +17,10 @@
* can be inserted into a message. This template provides a general no-op
* implementation for all other types.
*/
-template <typename T>
-T&& convertForMessage(T&& t)
+template <typename T> T&& convertForMessage(T&& t)
{
return std::forward<T>(t);
}
-
}
}
}
diff --git a/sdbusplus/server/interface.hpp b/sdbusplus/server/interface.hpp
index f3f6399..c09d301 100644
--- a/sdbusplus/server/interface.hpp
+++ b/sdbusplus/server/interface.hpp
@@ -31,14 +31,14 @@
*/
struct interface final
{
- /* Define all of the basic class operations:
- * Not allowed:
- * - Default constructor to avoid nullptrs.
- * - Copy operations due to internal unique_ptr.
- * Allowed:
- * - Move operations.
- * - Destructor.
- */
+ /* Define all of the basic class operations:
+ * Not allowed:
+ * - Default constructor to avoid nullptrs.
+ * - Copy operations due to internal unique_ptr.
+ * Allowed:
+ * - Move operations.
+ * - Destructor.
+ */
interface() = delete;
interface(const interface&) = delete;
interface& operator=(const interface&) = delete;
@@ -55,20 +55,16 @@
* @param[in] context - User-defined context, which is often 'this' from
* the interface implementation class.
*/
- interface(sdbusplus::bus::bus& bus,
- const char* path,
- const char* interf,
- const sdbusplus::vtable::vtable_t* vtable,
- void* context) :
- _bus(bus.get()), _path(path), _interf(interf),
- _slot(nullptr)
+ interface(sdbusplus::bus::bus& bus, const char* path, const char* interf,
+ const sdbusplus::vtable::vtable_t* vtable, void* context) :
+ _bus(bus.get()),
+ _path(path), _interf(interf), _slot(nullptr)
{
sd_bus_slot* slot = nullptr;
sd_bus_add_object_vtable(_bus.get(), &slot, _path.c_str(),
_interf.c_str(), vtable, context);
_slot = decltype(_slot){slot};
-
}
/** @brief Create a new signal message.
@@ -90,14 +86,20 @@
_interf.c_str(), property, nullptr);
}
- bus::bus& bus() { return _bus; }
- const std::string& path() { return _path; }
+ bus::bus& bus()
+ {
+ return _bus;
+ }
+ const std::string& path()
+ {
+ return _path;
+ }
- private:
- bus::bus _bus;
- std::string _path;
- std::string _interf;
- slot::slot _slot;
+ private:
+ bus::bus _bus;
+ std::string _path;
+ std::string _interf;
+ slot::slot _slot;
};
} // namespace interface
diff --git a/sdbusplus/server/manager.hpp b/sdbusplus/server/manager.hpp
index 5228b5f..55c2011 100644
--- a/sdbusplus/server/manager.hpp
+++ b/sdbusplus/server/manager.hpp
@@ -20,14 +20,14 @@
*/
struct manager
{
- /* Define all of the basic class operations:
- * Not allowed:
- * - Default constructor to avoid nullptrs.
- * - Copy operations due to internal unique_ptr.
- * Allowed:
- * - Move operations.
- * - Destructor.
- */
+ /* Define all of the basic class operations:
+ * Not allowed:
+ * - Default constructor to avoid nullptrs.
+ * - Copy operations due to internal unique_ptr.
+ * Allowed:
+ * - Move operations.
+ * - Destructor.
+ */
manager() = delete;
manager(const manager&) = delete;
manager& operator=(const manager&) = delete;
@@ -48,9 +48,8 @@
_slot = decltype(_slot){slot};
}
- private:
- slot::slot _slot;
-
+ private:
+ slot::slot _slot;
};
} // namespace manager
diff --git a/sdbusplus/server/object.hpp b/sdbusplus/server/object.hpp
index 6928164..802947b 100644
--- a/sdbusplus/server/object.hpp
+++ b/sdbusplus/server/object.hpp
@@ -18,31 +18,36 @@
* These allow an object to group multiple dbus interface bindings into a
* single class.
*/
-template <class T, class... Rest> struct compose_impl :
- T, compose_impl<Rest...>
+template <class T, class... Rest> struct compose_impl : T, compose_impl<Rest...>
{
compose_impl(bus::bus& bus, const char* path) :
- T(bus, path), compose_impl<Rest...>(bus, path) {}
+ T(bus, path), compose_impl<Rest...>(bus, path)
+ {
+ }
};
/** Specialization for single element. */
template <class T> struct compose_impl<T> : T
{
- compose_impl(bus::bus& bus, const char* path) :
- T(bus, path) {}
+ compose_impl(bus::bus& bus, const char* path) : T(bus, path)
+ {
+ }
};
/** Default compose operation for variadic arguments. */
template <class... Args> struct compose : compose_impl<Args...>
{
- compose(bus::bus& bus, const char* path) :
- compose_impl<Args...>(bus, path) {}
+ compose(bus::bus& bus, const char* path) : compose_impl<Args...>(bus, path)
+ {
+ }
};
/** Specialization for zero variadic arguments. */
template <> struct compose<>
{
- compose(bus::bus& bus, const char* path) {}
+ compose(bus::bus& bus, const char* path)
+ {
+ }
};
} // namespace details
@@ -59,17 +64,16 @@
* 'sd_bus_emit_object_removed' signals are emitted.
*
*/
-template<class... Args>
-struct object : details::compose<Args...>
+template <class... Args> struct object : details::compose<Args...>
{
- /* Define all of the basic class operations:
- * Not allowed:
- * - Default constructor to avoid nullptrs.
- * - Copy operations due to internal unique_ptr.
- * Allowed:
- * - Move operations.
- * - Destructor.
- */
+ /* Define all of the basic class operations:
+ * Not allowed:
+ * - Default constructor to avoid nullptrs.
+ * - Copy operations due to internal unique_ptr.
+ * Allowed:
+ * - Move operations.
+ * - Destructor.
+ */
object() = delete;
object(const object&) = delete;
object& operator=(const object&) = delete;
@@ -85,13 +89,11 @@
* object needs custom property init before the
* signal can be sent.
*/
- object(bus::bus& bus,
- const char* path,
- bool deferSignal = false)
- : details::compose<Args...>(bus, path),
- __sdbusplus_server_object_bus(bus.get()),
- __sdbusplus_server_object_path(path),
- __sdbusplus_server_object_emitremoved(false)
+ object(bus::bus& bus, const char* path, bool deferSignal = false) :
+ details::compose<Args...>(bus, path),
+ __sdbusplus_server_object_bus(bus.get()),
+ __sdbusplus_server_object_path(path),
+ __sdbusplus_server_object_emitremoved(false)
{
if (!deferSignal)
{
@@ -119,15 +121,14 @@
}
}
- private:
- // These member names are purposefully chosen as long and, hopefully,
- // unique. Since an object is 'composed' via multiple-inheritence,
- // all members need to have unique names to ensure there is no
- // ambiguity.
- bus::bus __sdbusplus_server_object_bus;
- std::string __sdbusplus_server_object_path;
- bool __sdbusplus_server_object_emitremoved;
-
+ private:
+ // These member names are purposefully chosen as long and, hopefully,
+ // unique. Since an object is 'composed' via multiple-inheritence,
+ // all members need to have unique names to ensure there is no
+ // ambiguity.
+ bus::bus __sdbusplus_server_object_bus;
+ std::string __sdbusplus_server_object_path;
+ bool __sdbusplus_server_object_emitremoved;
};
} // namespace object
diff --git a/sdbusplus/server/transaction.hpp b/sdbusplus/server/transaction.hpp
index 9e76a87..db07504 100644
--- a/sdbusplus/server/transaction.hpp
+++ b/sdbusplus/server/transaction.hpp
@@ -17,8 +17,9 @@
struct Transaction
{
- Transaction(): time(std::time(nullptr)), thread(std::this_thread::get_id())
- {}
+ Transaction() : time(std::time(nullptr)), thread(std::this_thread::get_id())
+ {
+ }
int time;
std::thread::id thread;
@@ -28,8 +29,10 @@
struct Transaction
{
- Transaction(sdbusplus::bus::bus &bus, sdbusplus::message::message& msg):
- bus(bus), msg(msg) {}
+ Transaction(sdbusplus::bus::bus& bus, sdbusplus::message::message& msg) :
+ bus(bus), msg(msg)
+ {
+ }
sdbusplus::bus::bus& bus;
sdbusplus::message::message& msg;
@@ -43,11 +46,9 @@
{
/** @ brief Overload of std::hash for sdbusplus::bus::bus */
-template <>
-struct hash<sdbusplus::bus::bus>
+template <> struct hash<sdbusplus::bus::bus>
{
- auto operator()
- (sdbusplus::bus::bus& b) const
+ auto operator()(sdbusplus::bus::bus& b) const
{
auto name = b.get_unique_name();
return std::hash<std::string>{}(name);
@@ -55,11 +56,9 @@
};
/** @ brief Overload of std::hash for sdbusplus::message::message */
-template <>
-struct hash<sdbusplus::message::message>
+template <> struct hash<sdbusplus::message::message>
{
- auto operator()
- (sdbusplus::message::message& m) const
+ auto operator()(sdbusplus::message::message& m) const
{
auto cookie = m.get_cookie();
return std::hash<uint64_t>{}(cookie);
@@ -67,34 +66,31 @@
};
/** @ brief Overload of std::hash for Transaction */
-template <>
-struct hash<sdbusplus::server::transaction::Transaction>
+template <> struct hash<sdbusplus::server::transaction::Transaction>
{
- auto operator()
- (sdbusplus::server::transaction::Transaction const& t) const
+ auto operator()(sdbusplus::server::transaction::Transaction const& t) const
{
auto hash1 = std::hash<sdbusplus::bus::bus>{}(t.bus);
auto hash2 = std::hash<sdbusplus::message::message>{}(t.msg);
// boost::hash_combine() algorithm.
- return static_cast<size_t>(hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) +
- (hash1 >> 2)));
+ return static_cast<size_t>(
+ hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2)));
}
};
/** @ brief Overload of std::hash for details::Transaction */
-template <>
-struct hash<sdbusplus::server::transaction::details::Transaction>
+template <> struct hash<sdbusplus::server::transaction::details::Transaction>
{
- auto operator()
- (sdbusplus::server::transaction::details::Transaction const& t) const
+ auto operator()(
+ sdbusplus::server::transaction::details::Transaction const& t) const
{
auto hash1 = std::hash<int>{}(t.time);
auto hash2 = std::hash<std::thread::id>{}(t.thread);
// boost::hash_combine() algorithm.
- return static_cast<size_t>(hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) +
- (hash1 >> 2)));
+ return static_cast<size_t>(
+ hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2)));
}
};
@@ -108,9 +104,9 @@
{
/** @brief Get transaction id
- *
- * @return The value of the transaction id
- */
+ *
+ * @return The value of the transaction id
+ */
inline uint64_t get_id()
{
// If the transaction id has not been initialized, generate one.
@@ -123,9 +119,9 @@
}
/** @brief Set transaction id
- *
- * @param[in] value - Desired value for the transaction id
- */
+ *
+ * @param[in] value - Desired value for the transaction id
+ */
inline void set_id(uint64_t value)
{
details::id = value;
diff --git a/sdbusplus/slot.hpp b/sdbusplus/slot.hpp
index 039f520..364d002 100644
--- a/sdbusplus/slot.hpp
+++ b/sdbusplus/slot.hpp
@@ -33,14 +33,14 @@
*/
struct slot
{
- /* Define all of the basic class operations:
- * Not allowed:
- * - Default constructor to avoid nullptrs.
- * - Copy operations due to internal unique_ptr.
- * Allowed:
- * - Move operations.
- * - Destructor.
- */
+ /* Define all of the basic class operations:
+ * Not allowed:
+ * - Default constructor to avoid nullptrs.
+ * - Copy operations due to internal unique_ptr.
+ * Allowed:
+ * - Move operations.
+ * - Destructor.
+ */
slot() = delete;
slot(const slot&) = delete;
slot& operator=(const slot&) = delete;
@@ -52,17 +52,24 @@
*
* Takes ownership of the slot-pointer and releases it when done.
*/
- explicit slot(slotp_t s) : _slot(s) {}
+ explicit slot(slotp_t s) : _slot(s)
+ {
+ }
/** @brief Release ownership of the stored slot-pointer. */
- slotp_t release() { return _slot.release(); }
+ slotp_t release()
+ {
+ return _slot.release();
+ }
/** @brief Check if slot contains a real pointer. (non-nullptr). */
- explicit operator bool() const { return bool(_slot); }
+ explicit operator bool() const
+ {
+ return bool(_slot);
+ }
- private:
- details::slot _slot;
-
+ private:
+ details::slot _slot;
};
} // namespace slot
diff --git a/sdbusplus/utility/tuple_to_array.hpp b/sdbusplus/utility/tuple_to_array.hpp
index b5ab2a5..fd57d1d 100644
--- a/sdbusplus/utility/tuple_to_array.hpp
+++ b/sdbusplus/utility/tuple_to_array.hpp
@@ -26,11 +26,12 @@
* @return A std::array where each I-th element is tuple's I-th element.
*/
template <typename V, typename... Types, std::size_t... I>
-constexpr auto tuple_to_array(
- std::tuple<V, Types...>&& tuple,
- std::integer_sequence<std::size_t, I...>)
+constexpr auto tuple_to_array(std::tuple<V, Types...>&& tuple,
+ std::integer_sequence<std::size_t, I...>)
{
- return std::array<V, sizeof...(I) >({ std::get<I>(tuple)..., });
+ return std::array<V, sizeof...(I)>({
+ std::get<I>(tuple)...,
+ });
}
} // namespace details
diff --git a/sdbusplus/utility/type_traits.hpp b/sdbusplus/utility/type_traits.hpp
index c5bf965..cad5168 100644
--- a/sdbusplus/utility/type_traits.hpp
+++ b/sdbusplus/utility/type_traits.hpp
@@ -15,12 +15,10 @@
*/
template <typename Tbase, typename T>
using array_to_ptr_t = typename std::conditional_t<
- std::is_array<T>::value,
- std::conditional_t<std::is_same<Tbase,
- std::remove_extent_t<T>>::value,
- std::add_pointer_t<std::remove_extent_t<T>>,
- T>,
- T>;
+ std::is_array<T>::value,
+ std::conditional_t<std::is_same<Tbase, std::remove_extent_t<T>>::value,
+ std::add_pointer_t<std::remove_extent_t<T>>, T>,
+ T>;
} // namespace utility
diff --git a/sdbusplus/vtable.hpp b/sdbusplus/vtable.hpp
index 7d9dfe8..939346e 100644
--- a/sdbusplus/vtable.hpp
+++ b/sdbusplus/vtable.hpp
@@ -7,13 +7,13 @@
namespace vtable
{
- /** Alias typedef for sd_bus_vtable */
+/** Alias typedef for sd_bus_vtable */
using vtable_t = sd_bus_vtable;
- /** Create a SD_BUS_VTABLE_START entry. */
+/** Create a SD_BUS_VTABLE_START entry. */
constexpr vtable_t start(decltype(vtable_t::flags) flags = 0);
- /** Create a SD_BUS_VTABLE_END entry. */
+/** Create a SD_BUS_VTABLE_END entry. */
constexpr vtable_t end();
/** Create a SD_BUS_VTABLE_METHOD entry.
@@ -39,8 +39,8 @@
*/
constexpr vtable_t method_o(const char* member, const char* signature,
const char* result,
- sd_bus_message_handler_t handler,
- size_t offset, decltype(vtable_t::flags) flags = 0);
+ sd_bus_message_handler_t handler, size_t offset,
+ decltype(vtable_t::flags) flags = 0);
/** Create a SD_BUS_SIGNAL entry.
*
@@ -100,16 +100,15 @@
namespace method_
{
- constexpr auto no_reply = SD_BUS_VTABLE_METHOD_NO_REPLY;
+constexpr auto no_reply = SD_BUS_VTABLE_METHOD_NO_REPLY;
} // namespace method_
namespace property_
{
- constexpr auto const_ = SD_BUS_VTABLE_PROPERTY_CONST;
- constexpr auto emits_change = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE;
- constexpr auto emits_invalidation =
- SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION;
- constexpr auto explicit_ = SD_BUS_VTABLE_PROPERTY_EXPLICIT;
+constexpr auto const_ = SD_BUS_VTABLE_PROPERTY_CONST;
+constexpr auto emits_change = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE;
+constexpr auto emits_invalidation = SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION;
+constexpr auto explicit_ = SD_BUS_VTABLE_PROPERTY_EXPLICIT;
} // namespace property_
constexpr vtable_t start(decltype(vtable_t::flags) flags)
@@ -117,7 +116,7 @@
vtable_t v{};
v.type = _SD_BUS_VTABLE_START;
v.flags = flags;
- v.x.start = decltype(v.x.start){ sizeof(vtable_t) };
+ v.x.start = decltype(v.x.start){sizeof(vtable_t)};
return v;
}
@@ -139,14 +138,14 @@
constexpr vtable_t method_o(const char* member, const char* signature,
const char* result,
- sd_bus_message_handler_t handler,
- size_t offset, decltype(vtable_t::flags) flags)
+ sd_bus_message_handler_t handler, size_t offset,
+ decltype(vtable_t::flags) flags)
{
vtable_t v{};
v.type = _SD_BUS_VTABLE_METHOD;
v.flags = flags;
v.x.method =
- decltype(v.x.method){ member, signature, result, handler, offset };
+ decltype(v.x.method){member, signature, result, handler, offset};
return v;
}
@@ -157,7 +156,7 @@
vtable_t v{};
v.type = _SD_BUS_VTABLE_SIGNAL;
v.flags = flags;
- v.x.signal = decltype(v.x.signal){ member, signature };
+ v.x.signal = decltype(v.x.signal){member, signature};
return v;
}
@@ -169,7 +168,7 @@
vtable_t v{};
v.type = _SD_BUS_VTABLE_PROPERTY;
v.flags = flags;
- v.x.property = decltype(v.x.property){ member, signature, get, nullptr, 0 };
+ v.x.property = decltype(v.x.property){member, signature, get, nullptr, 0};
return v;
}
@@ -182,20 +181,19 @@
vtable_t v{};
v.type = _SD_BUS_VTABLE_WRITABLE_PROPERTY;
v.flags = flags;
- v.x.property = decltype(v.x.property){ member, signature, get, set, 0 };
+ v.x.property = decltype(v.x.property){member, signature, get, set, 0};
return v;
}
constexpr vtable_t property_o(const char* member, const char* signature,
- size_t offset,
- decltype(vtable_t::flags) flags)
+ size_t offset, decltype(vtable_t::flags) flags)
{
vtable_t v{};
v.type = _SD_BUS_VTABLE_PROPERTY;
v.flags = flags;
- v.x.property = decltype(v.x.property)
- { member, signature, nullptr, nullptr, offset };
+ v.x.property =
+ decltype(v.x.property){member, signature, nullptr, nullptr, offset};
return v;
}
@@ -207,11 +205,10 @@
vtable_t v{};
v.type = _SD_BUS_VTABLE_WRITABLE_PROPERTY;
v.flags = flags;
- v.x.property = decltype(v.x.property)
- { member, signature, nullptr, set, offset };
+ v.x.property =
+ decltype(v.x.property){member, signature, nullptr, set, offset};
return v;
-
}
} // namespace vtable
diff --git a/test/bus/list_names.cpp b/test/bus/list_names.cpp
index 65333b7..a1967d9 100644
--- a/test/bus/list_names.cpp
+++ b/test/bus/list_names.cpp
@@ -5,17 +5,15 @@
class ListNames : public ::testing::Test
{
- protected:
- decltype(sdbusplus::bus::new_default()) bus =
- sdbusplus::bus::new_default();
+ protected:
+ decltype(sdbusplus::bus::new_default()) bus = sdbusplus::bus::new_default();
};
TEST_F(ListNames, NoServiceNameWithoutRequestName)
{
auto names = bus.list_names_acquired();
- EXPECT_EQ(names.cend(),
- std::find(names.cbegin(), names.cend(), this_name));
+ EXPECT_EQ(names.cend(), std::find(names.cbegin(), names.cend(), this_name));
}
TEST_F(ListNames, HasServiceNameAfterRequestName)
@@ -38,7 +36,6 @@
std::find(names.cbegin(), names.cend(), bus.get_unique_name()));
}
-
TEST_F(ListNames, HasDbusServer)
{
auto names = bus.list_names_acquired();
diff --git a/test/bus/match.cpp b/test/bus/match.cpp
index c69c76b..80bc259 100644
--- a/test/bus/match.cpp
+++ b/test/bus/match.cpp
@@ -4,41 +4,37 @@
class Match : public ::testing::Test
{
- protected:
- decltype(sdbusplus::bus::new_default()) bus =
- sdbusplus::bus::new_default();
+ protected:
+ decltype(sdbusplus::bus::new_default()) bus = sdbusplus::bus::new_default();
- static constexpr auto busName =
- "xyz.openbmc_project.sdbusplus.test.Match";
+ static constexpr auto busName = "xyz.openbmc_project.sdbusplus.test.Match";
+ static auto matchRule()
+ {
+ using namespace sdbusplus::bus::match::rules;
+ return nameOwnerChanged() + argN(0, busName);
+ }
- static auto matchRule()
+ void waitForIt(bool& triggered)
+ {
+ for (size_t i = 0; (i < 16) && !triggered; ++i)
{
- using namespace sdbusplus::bus::match::rules;
- return nameOwnerChanged() + argN(0, busName);
+ bus.wait(0);
+ bus.process_discard();
}
-
- void waitForIt(bool& triggered)
- {
- for (size_t i = 0; (i < 16) && !triggered; ++i)
- {
- bus.wait(0);
- bus.process_discard();
- }
- }
+ }
};
TEST_F(Match, FunctorIs_sd_bus_message_handler_t)
{
bool triggered = false;
- auto trigger = [](sd_bus_message *m, void* context, sd_bus_error* e)
- {
- *static_cast<bool*>(context) = true;
- return 0;
- };
+ auto trigger = [](sd_bus_message* m, void* context, sd_bus_error* e) {
+ *static_cast<bool*>(context) = true;
+ return 0;
+ };
sdbusplus::bus::match_t m{bus, matchRule(), trigger, &triggered};
- auto m2 = std::move(m); // ensure match is move-safe.
+ auto m2 = std::move(m); // ensure match is move-safe.
waitForIt(triggered);
ASSERT_FALSE(triggered);
@@ -52,13 +48,12 @@
TEST_F(Match, FunctorIs_LambdaTakingMessage)
{
bool triggered = false;
- auto trigger = [&triggered](sdbusplus::message::message& m)
- {
- triggered = true;
- };
+ auto trigger = [&triggered](sdbusplus::message::message& m) {
+ triggered = true;
+ };
sdbusplus::bus::match_t m{bus, matchRule(), trigger};
- auto m2 = std::move(m); // ensure match is move-safe.
+ auto m2 = std::move(m); // ensure match is move-safe.
waitForIt(triggered);
ASSERT_FALSE(triggered);
@@ -74,20 +69,20 @@
class BoolHolder
{
- public:
- bool triggered = false;
+ public:
+ bool triggered = false;
- void callback(sdbusplus::message::message& m)
- {
- triggered = true;
- }
+ void callback(sdbusplus::message::message& m)
+ {
+ triggered = true;
+ }
};
BoolHolder b;
sdbusplus::bus::match_t m{bus, matchRule(),
- std::bind(std::mem_fn(&BoolHolder::callback),
- &b, std::placeholders::_1)};
- auto m2 = std::move(m); // ensure match is move-safe.
+ std::bind(std::mem_fn(&BoolHolder::callback), &b,
+ std::placeholders::_1)};
+ auto m2 = std::move(m); // ensure match is move-safe.
waitForIt(b.triggered);
ASSERT_FALSE(b.triggered);
diff --git a/test/message/append.cpp b/test/message/append.cpp
index c3a06db..7782f02 100644
--- a/test/message/append.cpp
+++ b/test/message/append.cpp
@@ -6,7 +6,7 @@
// Global to share the dbus type string between client and server.
static std::string verifyTypeString;
-using verifyCallback_t = void(*)(sd_bus_message*);
+using verifyCallback_t = void (*)(sd_bus_message*);
verifyCallback_t verifyCallback = nullptr;
static constexpr auto SERVICE = "sdbusplus.test.message.append";
@@ -28,12 +28,12 @@
{
auto bus = sdbusplus::bus::bus(reinterpret_cast<sdbusplus::bus::busp_t>(b));
- while(1)
+ while (1)
{
// Wait for messages.
auto m = bus.process().release();
- if(m == nullptr)
+ if (m == nullptr)
{
bus.wait();
continue;
@@ -50,8 +50,8 @@
}
else
{
- std::cout << "Warning: No verification for "
- << verifyTypeString << std::endl;
+ std::cout << "Warning: No verification for " << verifyTypeString
+ << std::endl;
}
// Reply to client.
sd_bus_reply_method_return(m, nullptr);
@@ -233,8 +233,7 @@
const char* str3 = "1234";
const char* const str4 = "5678";
const auto str5 = "!@#$";
- m.append(1, "asdf", "ASDF"s, str,
- std::move(str2), str3, str4, str5, 5);
+ m.append(1, "asdf", "ASDF"s, str, std::move(str2), str3, str4, str5, 5);
verifyTypeString = "isssssssi";
struct verify
@@ -245,8 +244,8 @@
const char *s0 = nullptr, *s1 = nullptr, *s2 = nullptr,
*s3 = nullptr, *s4 = nullptr, *s5 = nullptr,
*s6 = nullptr;
- sd_bus_message_read(m, "isssssssi", &a, &s0, &s1, &s2, &s3,
- &s4, &s5, &s6, &b);
+ sd_bus_message_read(m, "isssssssi", &a, &s0, &s1, &s2, &s3, &s4,
+ &s5, &s6, &b);
assert(a == 1);
assert(b == 5);
assert(0 == strcmp("asdf", s0));
@@ -283,7 +282,6 @@
assert(b == 4);
assert(0 == strcmp("/asdf", s0));
assert(0 == strcmp("iii", s1));
-
}
};
verifyCallback = &verify::op;
@@ -294,7 +292,7 @@
// Test vector.
{
auto m = newMethodCall__test(b);
- std::vector<std::string> s{ "1", "2", "3"};
+ std::vector<std::string> s{"1", "2", "3"};
m.append(1, s, 2);
verifyTypeString = "iasi";
@@ -306,9 +304,8 @@
sd_bus_message_read(m, "i", &a);
assert(a == 1);
- auto rc = sd_bus_message_enter_container(m,
- SD_BUS_TYPE_ARRAY,
- "s");
+ auto rc =
+ sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
assert(0 <= rc);
const char* s = nullptr;
@@ -324,19 +321,17 @@
sd_bus_message_read(m, "i", &a);
assert(a == 2);
-
}
};
verifyCallback = &verify::op;
-
b.call_noreply(m);
}
// Test map.
{
auto m = newMethodCall__test(b);
- std::map<std::string, int> s = { { "asdf", 3 }, { "jkl;", 4 } };
+ std::map<std::string, int> s = {{"asdf", 3}, {"jkl;", 4}};
m.append(1, s, 2);
verifyTypeString = "ia{si}i";
@@ -348,13 +343,11 @@
sd_bus_message_read(m, "i", &a);
assert(a == 1);
- auto rc = sd_bus_message_enter_container(m,
- SD_BUS_TYPE_ARRAY,
+ auto rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY,
"{si}");
assert(0 <= rc);
- rc = sd_bus_message_enter_container(m,
- SD_BUS_TYPE_DICT_ENTRY,
+ rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
"si");
assert(0 <= rc);
@@ -367,8 +360,7 @@
assert(1 == sd_bus_message_at_end(m, false));
sd_bus_message_exit_container(m);
- rc = sd_bus_message_enter_container(m,
- SD_BUS_TYPE_DICT_ENTRY,
+ rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
"si");
assert(0 <= rc);
@@ -395,7 +387,7 @@
// Test tuple.
{
auto m = newMethodCall__test(b);
- std::tuple<int, double, std::string> a{ 3, 4.1, "asdf" };
+ std::tuple<int, double, std::string> a{3, 4.1, "asdf"};
m.append(1, a, 2);
verifyTypeString = "i(ids)i";
@@ -410,8 +402,7 @@
sd_bus_message_read(m, "i", &a);
assert(a == 1);
- auto rc = sd_bus_message_enter_container(m,
- SD_BUS_TYPE_STRUCT,
+ auto rc = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT,
"ids");
assert(0 <= rc);
@@ -470,8 +461,8 @@
// Test map-variant.
{
auto m = newMethodCall__test(b);
- std::map<std::string, sdbusplus::message::variant<int, double>> a1 =
- { { "asdf", 3 }, { "jkl;", 4.1 } };
+ std::map<std::string, sdbusplus::message::variant<int, double>> a1 = {
+ {"asdf", 3}, {"jkl;", 4.1}};
m.append(1, a1, 2);
verifyTypeString = "ia{sv}i";
diff --git a/test/message/native_types.cpp b/test/message/native_types.cpp
index 3b46457..eed7669 100644
--- a/test/message/native_types.cpp
+++ b/test/message/native_types.cpp
@@ -28,24 +28,24 @@
TEST(MessageNativeTypeConversions, SignatureInVector)
{
- std::vector<sdbusplus::message::signature> v =
- { sdbusplus::message::signature("iii") };
+ std::vector<sdbusplus::message::signature> v = {
+ sdbusplus::message::signature("iii")};
ASSERT_EQ(v.front(), "iii");
}
TEST(MessageNativeTypeConversions, SignatureInMap)
{
- std::map<sdbusplus::message::signature, int> m =
- { { sdbusplus::message::signature("iii"), 1 } };
+ std::map<sdbusplus::message::signature, int> m = {
+ {sdbusplus::message::signature("iii"), 1}};
ASSERT_EQ(m[sdbusplus::message::signature("iii")], 1);
}
TEST(MessageNativeTypeConversions, SignatureInUnorderedMap)
{
- std::unordered_map<sdbusplus::message::signature, int> u =
- { { sdbusplus::message::signature("iii"), 2 } };
+ std::unordered_map<sdbusplus::message::signature, int> u = {
+ {sdbusplus::message::signature("iii"), 2}};
ASSERT_EQ(u[sdbusplus::message::signature("iii")], 2);
}
diff --git a/test/message/read.cpp b/test/message/read.cpp
index 2b137d7..8c2c4ea 100644
--- a/test/message/read.cpp
+++ b/test/message/read.cpp
@@ -6,7 +6,7 @@
// Global to share the dbus type string between client and server.
static std::string verifyTypeString;
-using verifyCallback_t = void(*)(sdbusplus::message::message&);
+using verifyCallback_t = void (*)(sdbusplus::message::message&);
verifyCallback_t verifyCallback = nullptr;
static constexpr auto SERVICE = "sdbusplus.test.message.read";
@@ -28,12 +28,12 @@
{
auto bus = sdbusplus::bus::bus(reinterpret_cast<sdbusplus::bus::busp_t>(b));
- while(1)
+ while (1)
{
// Wait for messages.
auto m = bus.process();
- if(!m)
+ if (!m)
{
bus.wait();
continue;
@@ -52,8 +52,8 @@
}
else
{
- std::cout << "Warning: No verification for "
- << verifyTypeString << std::endl;
+ std::cout << "Warning: No verification for " << verifyTypeString
+ << std::endl;
}
// Reply to client.
sd_bus_reply_method_return(m.release(), nullptr);
@@ -133,7 +133,7 @@
static void op(sdbusplus::message::message& m)
{
int32_t a = 0, b = 0, c = 0, d = 0, e = 0;
- m.read(a,b,c,d,e);
+ m.read(a, b, c, d, e);
assert(a == 1);
assert(b == 2);
assert(c == 3);
@@ -200,8 +200,7 @@
auto m = newMethodCall__test(b);
auto str = "jkl;"s;
auto str2 = "JKL:"s;
- m.append(1, "asdf", "ASDF"s, str,
- std::move(str2), 5);
+ m.append(1, "asdf", "ASDF"s, str, std::move(str2), 5);
verifyTypeString = "issssi";
struct verify
@@ -251,11 +250,10 @@
b.call_noreply(m);
}
-
// Test vector.
{
auto m = newMethodCall__test(b);
- std::vector<std::string> s{ "1", "2", "3"};
+ std::vector<std::string> s{"1", "2", "3"};
m.append(1, s, 2);
verifyTypeString = "iasi";
@@ -270,7 +268,7 @@
assert(s[0] == "1");
assert(s[1] == "2");
assert(s[2] == "3");
- decltype(s) s2 = { "1" , "2" , "3" };
+ decltype(s) s2 = {"1", "2", "3"};
assert(s == s2);
}
};
@@ -282,7 +280,7 @@
// Test map.
{
auto m = newMethodCall__test(b);
- std::map<std::string, int> s = { { "asdf", 3 }, { "jkl;", 4 } };
+ std::map<std::string, int> s = {{"asdf", 3}, {"jkl;", 4}};
m.append(1, s, 2);
verifyTypeString = "ia{si}i";
@@ -309,7 +307,7 @@
// Test tuple.
{
auto m = newMethodCall__test(b);
- std::tuple<int, double, std::string> a{ 3, 4.1, "asdf" };
+ std::tuple<int, double, std::string> a{3, 4.1, "asdf"};
m.append(1, a, 2);
verifyTypeString = "i(ids)i";
@@ -386,8 +384,8 @@
// Test map-variant.
{
auto m = newMethodCall__test(b);
- std::map<std::string, sdbusplus::message::variant<int, double>> a1 =
- { { "asdf", 3 }, { "jkl;", 4.1 } };
+ std::map<std::string, sdbusplus::message::variant<int, double>> a1 = {
+ {"asdf", 3}, {"jkl;", 4.1}};
m.append(1, a1, 2);
verifyTypeString = "ia{sv}i";
@@ -396,8 +394,8 @@
static void op(sdbusplus::message::message& m)
{
int32_t a = 0, b = 0;
- std::map<std::string,
- sdbusplus::message::variant<int, double>> a1{};
+ std::map<std::string, sdbusplus::message::variant<int, double>>
+ a1{};
m.read(a, a1, b);
assert(a == 1);
@@ -411,7 +409,6 @@
b.call_noreply(m);
}
-
// Shutdown server.
{
auto m = b.new_method_call(SERVICE, "/", INTERFACE, QUIT_METHOD);
diff --git a/test/message/types.cpp b/test/message/types.cpp
index 604996e..e779c79 100644
--- a/test/message/types.cpp
+++ b/test/message/types.cpp
@@ -2,17 +2,16 @@
#include <sdbusplus/message/types.hpp>
#include <sdbusplus/utility/tuple_to_array.hpp>
-template <typename ...Args>
-auto dbus_string(Args&& ... args)
+template <typename... Args> auto dbus_string(Args&&... args)
{
- return std::string(
- sdbusplus::utility::tuple_to_array(
- sdbusplus::message::types::type_id<Args...>()).data());
+ return std::string(sdbusplus::utility::tuple_to_array(
+ sdbusplus::message::types::type_id<Args...>())
+ .data());
}
TEST(MessageTypes, Integer)
{
- ASSERT_EQ(dbus_string(1),"i");
+ ASSERT_EQ(dbus_string(1), "i");
}
TEST(MessageTypes, Double)
diff --git a/test/utility/type_traits.cpp b/test/utility/type_traits.cpp
index 3a31d06..f2beed7 100644
--- a/test/utility/type_traits.cpp
+++ b/test/utility/type_traits.cpp
@@ -4,17 +4,14 @@
{
using sdbusplus::utility::array_to_ptr_t;
- static_assert(
- std::is_same<char, array_to_ptr_t<char, char>>::value,
- "array_to_ptr_t<char, char> != char");
+ static_assert(std::is_same<char, array_to_ptr_t<char, char>>::value,
+ "array_to_ptr_t<char, char> != char");
- static_assert(
- std::is_same<char*, array_to_ptr_t<char, char*>>::value,
- "array_to_ptr_t<char, char*> != char*");
+ static_assert(std::is_same<char*, array_to_ptr_t<char, char*>>::value,
+ "array_to_ptr_t<char, char*> != char*");
- static_assert(
- std::is_same<char*, array_to_ptr_t<char, char[100]>>::value,
- "array_to_ptr_t<char, char[100]> != char*");
+ static_assert(std::is_same<char*, array_to_ptr_t<char, char[100]>>::value,
+ "array_to_ptr_t<char, char[100]> != char*");
static_assert(
std::is_same<char[100], array_to_ptr_t<int, char[100]>>::value,
diff --git a/test/vtable/vtable.cpp b/test/vtable/vtable.cpp
index ab1e34a..bc67382 100644
--- a/test/vtable/vtable.cpp
+++ b/test/vtable/vtable.cpp
@@ -1,22 +1,19 @@
#include <sdbusplus/vtable.hpp>
#include <gtest/gtest.h>
-static const sdbusplus::vtable::vtable_t example[] =
- {
- sdbusplus::vtable::start(),
- sdbusplus::vtable::method((const char*)1, (const char*)2,
- (const char*)3,
- (sd_bus_message_handler_t)4),
- sdbusplus::vtable::signal((const char*)5, (const char*)6),
- sdbusplus::vtable::property((const char*)7, (const char*)8,
- (sd_bus_property_get_t)9,
- sdbusplus::vtable::property_::const_),
- sdbusplus::vtable::property((const char*)10, (const char*)11,
- (sd_bus_property_get_t)12,
- (sd_bus_property_set_t)13),
- sdbusplus::vtable::property_o((const char*)14, (const char*)15, 16),
- sdbusplus::vtable::end()
- };
+static const sdbusplus::vtable::vtable_t example[] = {
+ sdbusplus::vtable::start(),
+ sdbusplus::vtable::method((const char*)1, (const char*)2, (const char*)3,
+ (sd_bus_message_handler_t)4),
+ sdbusplus::vtable::signal((const char*)5, (const char*)6),
+ sdbusplus::vtable::property((const char*)7, (const char*)8,
+ (sd_bus_property_get_t)9,
+ sdbusplus::vtable::property_::const_),
+ sdbusplus::vtable::property((const char*)10, (const char*)11,
+ (sd_bus_property_get_t)12,
+ (sd_bus_property_set_t)13),
+ sdbusplus::vtable::property_o((const char*)14, (const char*)15, 16),
+ sdbusplus::vtable::end()};
extern const sd_bus_vtable example2[];
extern const size_t example2_size;
diff --git a/test/vtable/vtable_c.c b/test/vtable/vtable_c.c
index 442d6c7..d01506b 100644
--- a/test/vtable/vtable_c.c
+++ b/test/vtable/vtable_c.c
@@ -1,21 +1,17 @@
#include <systemd/sd-bus.h>
-
-const sd_bus_vtable example2[] =
- {
- SD_BUS_VTABLE_START(0),
- SD_BUS_METHOD((const char*)1, (const char*)2,
- (const char*)3, (sd_bus_message_handler_t)4, 0),
- SD_BUS_SIGNAL((const char*)5, (const char*)6, 0),
- SD_BUS_PROPERTY((const char*)7, (const char*)8,
- (sd_bus_property_get_t)9, 0,
- SD_BUS_VTABLE_PROPERTY_CONST),
- SD_BUS_WRITABLE_PROPERTY((const char*)10, (const char*)11,
- (sd_bus_property_get_t)12,
- (sd_bus_property_set_t)13, 0, 0),
- SD_BUS_PROPERTY((const char*)14, (const char*)15, NULL, 16, 0),
- SD_BUS_VTABLE_END,
- };
+const sd_bus_vtable example2[] = {
+ SD_BUS_VTABLE_START(0),
+ SD_BUS_METHOD((const char*)1, (const char*)2, (const char*)3,
+ (sd_bus_message_handler_t)4, 0),
+ SD_BUS_SIGNAL((const char*)5, (const char*)6, 0),
+ SD_BUS_PROPERTY((const char*)7, (const char*)8, (sd_bus_property_get_t)9, 0,
+ SD_BUS_VTABLE_PROPERTY_CONST),
+ SD_BUS_WRITABLE_PROPERTY((const char*)10, (const char*)11,
+ (sd_bus_property_get_t)12,
+ (sd_bus_property_set_t)13, 0, 0),
+ SD_BUS_PROPERTY((const char*)14, (const char*)15, NULL, 16, 0),
+ SD_BUS_VTABLE_END,
+};
const size_t example2_size = sizeof(example2);
-