27#ifndef SDBUS_CXX_MESSAGE_H_
28#define SDBUS_CXX_MESSAGE_H_
41# if __has_include(<span>)
47#include <unordered_map>
57 template <
typename... _ValueTypes>
class Struct;
90 Message& operator<<(int16_t item);
91 Message& operator<<(int32_t item);
92 Message& operator<<(int64_t item);
93 Message& operator<<(uint8_t item);
94 Message& operator<<(uint16_t item);
95 Message& operator<<(uint32_t item);
96 Message& operator<<(uint64_t item);
97 Message& operator<<(
double item);
98 Message& operator<<(
const char *item);
99 Message& operator<<(
const std::string &item);
100 Message& operator<<(std::string_view item);
102 template <
typename ...Elements>
103 Message& operator<<(
const std::variant<Elements...>& value);
107 template <
typename _Element,
typename _Allocator>
108 Message& operator<<(
const std::vector<_Element, _Allocator>& items);
109 template <
typename _Element, std::
size_t _Size>
110 Message& operator<<(
const std::array<_Element, _Size>& items);
112 template <
typename _Element, std::
size_t _Extent>
113 Message& operator<<(
const std::span<_Element, _Extent>& items);
115 template <
typename _Enum,
typename = std::enable_if_t<std::is_enum_v<_Enum>>>
116 Message& operator<<(
const _Enum& item);
117 template <
typename _Key,
typename _Value,
typename _Compare,
typename _Allocator>
118 Message& operator<<(
const std::map<_Key, _Value, _Compare, _Allocator>& items);
119 template <
typename _Key,
typename _Value,
typename _Hash,
typename _KeyEqual,
typename _Allocator>
120 Message& operator<<(
const std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items);
121 template <
typename... _ValueTypes>
123 template <
typename... _ValueTypes>
124 Message& operator<<(
const std::tuple<_ValueTypes...>& item);
126 Message& operator>>(
bool& item);
127 Message& operator>>(int16_t& item);
128 Message& operator>>(int32_t& item);
129 Message& operator>>(int64_t& item);
130 Message& operator>>(uint8_t& item);
131 Message& operator>>(uint16_t& item);
132 Message& operator>>(uint32_t& item);
133 Message& operator>>(uint64_t& item);
134 Message& operator>>(
double& item);
135 Message& operator>>(
char*& item);
136 Message& operator>>(std::string &item);
138 template <
typename ...Elements>
139 Message& operator>>(std::variant<Elements...>& value);
143 template <
typename _Element,
typename _Allocator>
144 Message& operator>>(std::vector<_Element, _Allocator>& items);
145 template <
typename _Element, std::
size_t _Size>
146 Message& operator>>(std::array<_Element, _Size>& items);
148 template <
typename _Element, std::
size_t _Extent>
149 Message& operator>>(std::span<_Element, _Extent>& items);
151 template <
typename _Enum,
typename = std::enable_if_t<std::is_enum_v<_Enum>>>
152 Message& operator>>(_Enum& item);
153 template <
typename _Key,
typename _Value,
typename _Compare,
typename _Allocator>
154 Message& operator>>(std::map<_Key, _Value, _Compare, _Allocator>& items);
155 template <
typename _Key,
typename _Value,
typename _Hash,
typename _KeyEqual,
typename _Allocator>
156 Message& operator>>(std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items);
157 template <
typename... _ValueTypes>
159 template <
typename... _ValueTypes>
160 Message& operator>>(std::tuple<_ValueTypes...>& item);
162 template <
typename _ElementType>
164 Message& openContainer(
const char* signature);
166 template <
typename _KeyType,
typename _ValueType>
168 Message& openDictEntry(
const char* signature);
170 template <
typename _ValueType>
172 Message& openVariant(
const char* signature);
174 template <
typename... _ValueTypes>
176 Message& openStruct(
const char* signature);
179 template <
typename _ElementType>
181 Message& enterContainer(
const char* signature);
183 template <
typename _KeyType,
typename _ValueType>
185 Message& enterDictEntry(
const char* signature);
187 template <
typename _ValueType>
189 Message& enterVariant(
const char* signature);
191 template <
typename... _ValueTypes>
193 Message& enterStruct(
const char* signature);
196 Message& appendArray(
char type,
const void *ptr,
size_t size);
197 Message& readArray(
char type,
const void **ptr,
size_t *size);
199 explicit operator bool()
const;
202 const char* getInterfaceName()
const;
203 const char* getMemberName()
const;
204 const char* getSender()
const;
205 const char* getPath()
const;
206 const char* getDestination()
const;
208 std::pair<char, const char*> peekType()
const;
209 bool isValid()
const;
210 bool isEmpty()
const;
211 bool isAtEnd(
bool complete)
const;
213 void copyTo(
Message& destination,
bool complete)
const;
215 void rewind(
bool complete);
217 pid_t getCredsPid()
const;
218 uid_t getCredsUid()
const;
219 uid_t getCredsEuid()
const;
220 gid_t getCredsGid()
const;
221 gid_t getCredsEgid()
const;
222 std::vector<gid_t> getCredsSupplementaryGids()
const;
223 std::string getSELinuxContext()
const;
228 template <
typename _Array>
229 void serializeArray(
const _Array& items);
230 template <
typename _Array>
231 void deserializeArray(_Array& items);
232 template <
typename _Array>
233 void deserializeArrayFast(_Array& items);
234 template <
typename _Element,
typename _Allocator>
235 void deserializeArrayFast(std::vector<_Element, _Allocator>& items);
236 template <
typename _Array>
237 void deserializeArraySlow(_Array& items);
238 template <
typename _Element,
typename _Allocator>
239 void deserializeArraySlow(std::vector<_Element, _Allocator>& items);
241 template <
typename _Dictionary>
242 void serializeDictionary(
const _Dictionary& items);
243 template <
typename _Dictionary>
244 void deserializeDictionary(_Dictionary& items);
248 explicit Message(internal::IConnection* connection)
noexcept;
249 Message(
void *msg, internal::IConnection* connection)
noexcept;
256 internal::IConnection* connection_{};
257 mutable bool ok_{
true};
262 using Message::Message;
269 [[nodiscard]] Slot send(
void* callback,
void* userData, uint64_t timeout,
return_slot_t)
const;
274 void dontExpectReply();
275 bool doesntExpectReply()
const;
281 MethodReply sendWithReply(uint64_t timeout = 0)
const;
287 using Message::Message;
297 using Message::Message;
302 void setDestination(
const std::string& destination);
303 void setDestination(
const char* destination);
309 using Message::Message;
318 using Message::Message;
328 using Message::Message;
337 template <
typename ...Elements>
338 inline Message& Message::operator<<(
const std::variant<Elements...>& value)
340 std::visit([
this](
const auto& inner)
342 openVariant<decltype(inner)>();
350 template <
typename _Element,
typename _Allocator>
351 inline Message& Message::operator<<(
const std::vector<_Element, _Allocator>& items)
353 serializeArray(items);
358 template <
typename _Element, std::
size_t _Size>
359 inline Message& Message::operator<<(
const std::array<_Element, _Size>& items)
361 serializeArray(items);
367 template <
typename _Element, std::
size_t _Extent>
368 inline Message& Message::operator<<(
const std::span<_Element, _Extent>& items)
370 serializeArray(items);
376 template <
typename _Enum,
typename>
377 inline Message& Message::operator<<(
const _Enum &item)
379 return operator<<(
static_cast<std::underlying_type_t<_Enum>
>(item));
382 template <
typename _Array>
383 inline void Message::serializeArray(
const _Array& items)
385 using ElementType =
typename _Array::value_type;
389 if constexpr (signature_of<ElementType>::is_trivial_dbus_type && !std::is_same_v<ElementType, bool>)
391 constexpr auto signature = as_null_terminated(signature_of_v<ElementType>);
392 appendArray(*signature.data(), items.data(), items.size() *
sizeof(ElementType));
396 openContainer<ElementType>();
398 for (
const auto& item : items)
405 template <
typename _Key,
typename _Value,
typename _Compare,
typename _Allocator>
406 inline Message& Message::operator<<(
const std::map<_Key, _Value, _Compare, _Allocator>& items)
408 serializeDictionary(items);
413 template <
typename _Key,
typename _Value,
typename _Hash,
typename _KeyEqual,
typename _Allocator>
414 inline Message& Message::operator<<(
const std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items)
416 serializeDictionary(items);
421 template <
typename _Dictionary>
422 inline void Message::serializeDictionary(
const _Dictionary& items)
424 using KeyType =
typename _Dictionary::key_type;
425 using MappedType =
typename _Dictionary::mapped_type;
427 openContainer<DictEntry<KeyType, MappedType>>();
429 for (
const auto& item : items)
431 openDictEntry<KeyType, MappedType>();
433 *
this << item.second;
442 template <
typename... _Args>
443 void serialize_pack(Message& msg, _Args&&... args)
445 (void)(msg << ... << args);
448 template <
class _Tuple, std::size_t... _Is>
449 void serialize_tuple( Message& msg
451 , std::index_sequence<_Is...>)
453 serialize_pack(msg, std::get<_Is>(t)...);
457 template <
typename... _ValueTypes>
458 inline Message& Message::operator<<(
const Struct<_ValueTypes...>& item)
460 openStruct<_ValueTypes...>();
461 detail::serialize_tuple(*
this, item, std::index_sequence_for<_ValueTypes...>{});
467 template <
typename... _ValueTypes>
468 inline Message& Message::operator<<(
const std::tuple<_ValueTypes...>& item)
470 detail::serialize_tuple(*
this, item, std::index_sequence_for<_ValueTypes...>{});
476 template <
typename _Element,
typename... _Elements>
477 bool deserialize_variant(Message& msg, std::variant<_Elements...>& value,
const char* signature)
479 constexpr auto elemSignature = as_null_terminated(sdbus::signature_of_v<_Element>);
480 if (std::strcmp(signature, elemSignature.data()) != 0)
484 msg.enterVariant(signature);
487 value = std::move(temp);
492 template <
typename... Elements>
493 inline Message& Message::operator>>(std::variant<Elements...>& value)
495 auto [type, contents] = peekType();
496 bool result = (detail::deserialize_variant<Elements>(*
this, value, contents) || ...);
497 SDBUS_THROW_ERROR_IF(!result,
"Failed to deserialize variant: signature did not match any of the variant types", EINVAL);
501 template <
typename _Element,
typename _Allocator>
502 inline Message& Message::operator>>(std::vector<_Element, _Allocator>& items)
504 deserializeArray(items);
509 template <
typename _Element, std::
size_t _Size>
510 inline Message& Message::operator>>(std::array<_Element, _Size>& items)
512 deserializeArray(items);
518 template <
typename _Element, std::
size_t _Extent>
519 inline Message& Message::operator>>(std::span<_Element, _Extent>& items)
521 deserializeArray(items);
527 template <
typename _Enum,
typename>
528 inline Message& Message::operator>>(_Enum& item)
530 std::underlying_type_t<_Enum> val;
532 item =
static_cast<_Enum
>(val);
536 template <
typename _Array>
537 inline void Message::deserializeArray(_Array& items)
539 using ElementType =
typename _Array::value_type;
543 if constexpr (signature_of<ElementType>::is_trivial_dbus_type && !std::is_same_v<ElementType, bool>)
545 deserializeArrayFast(items);
549 deserializeArraySlow(items);
553 template <
typename _Array>
554 inline void Message::deserializeArrayFast(_Array& items)
556 using ElementType =
typename _Array::value_type;
559 const ElementType* arrayPtr{};
561 constexpr auto signature = as_null_terminated(sdbus::signature_of_v<ElementType>);
562 readArray(*signature.data(), (
const void**)&arrayPtr, &arraySize);
564 size_t elementsInMsg = arraySize /
sizeof(ElementType);
565 bool notEnoughSpace = items.size() < elementsInMsg;
566 SDBUS_THROW_ERROR_IF(notEnoughSpace,
"Failed to deserialize array: not enough space in destination sequence", EINVAL);
568 std::copy_n(arrayPtr, elementsInMsg, items.begin());
571 template <
typename _Element,
typename _Allocator>
572 void Message::deserializeArrayFast(std::vector<_Element, _Allocator>& items)
575 const _Element* arrayPtr{};
577 constexpr auto signature = as_null_terminated(sdbus::signature_of_v<_Element>);
578 readArray(*signature.data(), (
const void**)&arrayPtr, &arraySize);
580 items.insert(items.end(), arrayPtr, arrayPtr + (arraySize /
sizeof(_Element)));
583 template <
typename _Array>
584 inline void Message::deserializeArraySlow(_Array& items)
586 using ElementType =
typename _Array::value_type;
588 if(!enterContainer<ElementType>())
591 for (
auto& elem : items)
592 if (!(*this >> elem))
595 SDBUS_THROW_ERROR_IF(!isAtEnd(
false),
"Failed to deserialize array: not enough space in destination sequence", EINVAL);
602 template <
typename _Element,
typename _Allocator>
603 void Message::deserializeArraySlow(std::vector<_Element, _Allocator>& items)
605 if(!enterContainer<_Element>())
612 items.emplace_back(std::move(elem));
622 template <
typename _Key,
typename _Value,
typename _Compare,
typename _Allocator>
623 inline Message& Message::operator>>(std::map<_Key, _Value, _Compare, _Allocator>& items)
625 deserializeDictionary(items);
630 template <
typename _Key,
typename _Value,
typename _Hash,
typename _KeyEqual,
typename _Allocator>
631 inline Message& Message::operator>>(std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items)
633 deserializeDictionary(items);
638 template <
typename _Dictionary>
639 inline void Message::deserializeDictionary(_Dictionary& items)
641 using KeyType =
typename _Dictionary::key_type;
642 using MappedType =
typename _Dictionary::mapped_type;
644 if (!enterContainer<DictEntry<KeyType, MappedType>>())
649 if (!enterDictEntry<KeyType, MappedType>())
654 *
this >> key >> value;
656 items.emplace(std::move(key), std::move(value));
668 template <
typename... _Args>
669 void deserialize_pack(Message& msg, _Args&... args)
671 (void)(msg >> ... >> args);
674 template <
class _Tuple, std::size_t... _Is>
675 void deserialize_tuple( Message& msg
677 , std::index_sequence<_Is...> )
679 deserialize_pack(msg, std::get<_Is>(t)...);
683 template <
typename... _ValueTypes>
684 inline Message& Message::operator>>(Struct<_ValueTypes...>& item)
686 if (!enterStruct<_ValueTypes...>())
689 detail::deserialize_tuple(*
this, item, std::index_sequence_for<_ValueTypes...>{});
696 template <
typename... _ValueTypes>
697 inline Message& Message::operator>>(std::tuple<_ValueTypes...>& item)
699 detail::deserialize_tuple(*
this, item, std::index_sequence_for<_ValueTypes...>{});
703 template <
typename _ElementType>
704 inline Message& Message::openContainer()
706 constexpr auto signature = as_null_terminated(signature_of_v<_ElementType>);
707 return openContainer(signature.data());
710 template <
typename _KeyType,
typename _ValueType>
711 inline Message& Message::openDictEntry()
713 constexpr auto signature = as_null_terminated(signature_of_v<std::tuple<_KeyType, _ValueType>>);
714 return openDictEntry(signature.data());
717 template <
typename _ValueType>
718 inline Message& Message::openVariant()
720 constexpr auto signature = as_null_terminated(signature_of_v<_ValueType>);
721 return openVariant(signature.data());
724 template <
typename... _ValueTypes>
725 inline Message& Message::openStruct()
727 constexpr auto signature = as_null_terminated(signature_of_v<std::tuple<_ValueTypes...>>);
728 return openStruct(signature.data());
731 template <
typename _ElementType>
732 inline Message& Message::enterContainer()
734 constexpr auto signature = as_null_terminated(signature_of_v<_ElementType>);
735 return enterContainer(signature.data());
738 template <
typename _KeyType,
typename _ValueType>
739 inline Message& Message::enterDictEntry()
741 constexpr auto signature = as_null_terminated(signature_of_v<std::tuple<_KeyType, _ValueType>>);
742 return enterDictEntry(signature.data());
745 template <
typename _ValueType>
746 inline Message& Message::enterVariant()
748 constexpr auto signature = as_null_terminated(signature_of_v<_ValueType>);
749 return enterVariant(signature.data());
752 template <
typename... _ValueTypes>
753 inline Message& Message::enterStruct()
755 constexpr auto signature = as_null_terminated(signature_of_v<std::tuple<_ValueTypes...>>);
756 return enterStruct(signature.data());
Definition TypeTraits.h:94
Definition TypeTraits.h:88