// Copyright 2014 The Chromium OS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef LIBBRILLO_BRILLO_DBUS_DATA_SERIALIZATION_H_ #define LIBBRILLO_BRILLO_DBUS_DATA_SERIALIZATION_H_ // The main functionality provided by this header file is methods to serialize // native C++ data over D-Bus. This includes three major parts: // - Methods to get the D-Bus signature for a given C++ type: // std::string GetDBusSignature<T>(); // - Methods to write arbitrary C++ data to D-Bus MessageWriter: // void AppendValueToWriter(dbus::MessageWriter* writer, const T& value); // void AppendValueToWriterAsVariant(dbus::MessageWriter*, const T&); // - Methods to read arbitrary C++ data from D-Bus MessageReader: // bool PopValueFromReader(dbus::MessageReader* reader, T* value); // bool PopVariantValueFromReader(dbus::MessageReader* reader, T* value); // // There are a number of overloads to handle C++ equivalents of basic D-Bus // types: // D-Bus Type | D-Bus Signature | Native C++ type // -------------------------------------------------- // BYTE | y | uint8_t // BOOL | b | bool // INT16 | n | int16_t // UINT16 | q | uint16_t // INT32 | i | int32_t (int) // UINT32 | u | uint32_t (unsigned) // INT64 | x | int64_t // UINT64 | t | uint64_t // DOUBLE | d | double // STRING | s | std::string // OBJECT_PATH | o | dbus::ObjectPath // ARRAY | aT | std::vector<T> // STRUCT | (UV) | std::pair<U,V> // | (UVW...) | std::tuple<U,V,W,...> // DICT | a{KV} | std::map<K,V> // VARIANT | v | brillo::Any // UNIX_FD | h | dbus::FileDescriptor // SIGNATURE | g | (unsupported) // // Additional overloads/specialization can be provided for custom types. // In order to do that, provide overloads of AppendValueToWriter() and // PopValueFromReader() functions in brillo::dbus_utils namespace for the // CustomType. As well as a template specialization of DBusType<> for the same // CustomType. This specialization must provide three static functions: // - static std::string GetSignature(); // - static void Write(dbus::MessageWriter* writer, const CustomType& value); // - static bool Read(dbus::MessageReader* reader, CustomType* value); // See an example in DBusUtils.CustomStruct unit test in // brillo/dbus/data_serialization_unittest.cc. #include <map> #include <memory> #include <string> #include <tuple> #include <utility> #include <vector> #include <base/logging.h> #include <brillo/brillo_export.h> #include <brillo/type_name_undecorate.h> #include <dbus/message.h> namespace google { namespace protobuf { class MessageLite; } // namespace protobuf } // namespace google namespace brillo { // Forward-declare only. Can't include any.h right now because it needs // AppendValueToWriter() declared below. class Any; namespace dbus_utils { // Base class for DBusType<T> for T not supported by D-Bus. This used to // implement IsTypeSupported<> below. struct Unsupported {}; // Generic definition of DBusType<T> which will be specialized for particular // types later. // The second template parameter is used only in SFINAE situations to resolve // class hierarchy chains for protobuf-derived classes. This type is defaulted // to be 'void' in all other cases and simply ignored. // See DBusType specialization for google::protobuf::MessageLite below for more // detailed information. template<typename T, typename = void> struct DBusType : public Unsupported {}; // A helper type trait to determine if all of the types listed in Types... are // supported by D-Bus. This is a generic forward-declaration which will be // specialized for different type combinations. template<typename... Types> struct IsTypeSupported; // Both T and the Types... must be supported for the complete set to be // supported. template<typename T, typename... Types> struct IsTypeSupported<T, Types...> : public std::integral_constant< bool, IsTypeSupported<T>::value && IsTypeSupported<Types...>::value> {}; // For a single type T, check if DBusType<T> derives from Unsupported. // If it does, then the type is not supported by the D-Bus. template<typename T> struct IsTypeSupported<T> : public std::integral_constant< bool, !std::is_base_of<Unsupported, DBusType<T>>::value> {}; // Empty set is not supported. template<> struct IsTypeSupported<> : public std::false_type {}; //---------------------------------------------------------------------------- // AppendValueToWriter<T>(dbus::MessageWriter* writer, const T& value) // Write the |value| of type T to D-Bus message. // Explicitly delete the overloads for scalar types that are not supported by // D-Bus. void AppendValueToWriter(dbus::MessageWriter* writer, char value) = delete; void AppendValueToWriter(dbus::MessageWriter* writer, float value) = delete; //---------------------------------------------------------------------------- // PopValueFromReader<T>(dbus::MessageWriter* writer, T* value) // Reads the |value| of type T from D-Bus message. // Explicitly delete the overloads for scalar types that are not supported by // D-Bus. void PopValueFromReader(dbus::MessageReader* reader, char* value) = delete; void PopValueFromReader(dbus::MessageReader* reader, float* value) = delete; //---------------------------------------------------------------------------- // Get D-Bus data signature from C++ data types. // Specializations of a generic GetDBusSignature<T>() provide signature strings // for native C++ types. This function is available only for type supported // by D-Bus. template<typename T> inline typename std::enable_if<IsTypeSupported<T>::value, std::string>::type GetDBusSignature() { return DBusType<T>::GetSignature(); } namespace details { // Helper method used by the many overloads of PopValueFromReader(). // If the current value in the reader is of Variant type, the method descends // into the Variant and updates the |*reader_ref| with the transient // |variant_reader| MessageReader instance passed in. // Returns false if it fails to descend into the Variant. inline bool DescendIntoVariantIfPresent(dbus::MessageReader** reader_ref, dbus::MessageReader* variant_reader) { if ((*reader_ref)->GetDataType() != dbus::Message::VARIANT) return true; if (!(*reader_ref)->PopVariant(variant_reader)) return false; *reader_ref = variant_reader; return true; } // Helper method to format the type string of an array. // Essentially it adds "a" in front of |element_signature|. inline std::string GetArrayDBusSignature(const std::string& element_signature) { return DBUS_TYPE_ARRAY_AS_STRING + element_signature; } // Helper method to get a signature string for DICT_ENTRY. // Returns "{KV}", where "K" and "V" are the type signatures for types // KEY/VALUE. For example, GetDBusDictEntryType<std::string, int>() would return // "{si}". template<typename KEY, typename VALUE> inline std::string GetDBusDictEntryType() { return DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + GetDBusSignature<KEY>() + GetDBusSignature<VALUE>() + DBUS_DICT_ENTRY_END_CHAR_AS_STRING; } } // namespace details //============================================================================= // Specializations/overloads for AppendValueToWriter, PopValueFromReader and // DBusType<T> for various C++ types that can be serialized over D-Bus. // bool ----------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, bool value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, bool* value); template<> struct DBusType<bool> { inline static std::string GetSignature() { return DBUS_TYPE_BOOLEAN_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, bool value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, bool* value) { return PopValueFromReader(reader, value); } }; // uint8_t -------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, uint8_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, uint8_t* value); template<> struct DBusType<uint8_t> { inline static std::string GetSignature() { return DBUS_TYPE_BYTE_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, uint8_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, uint8_t* value) { return PopValueFromReader(reader, value); } }; // int16_t -------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, int16_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, int16_t* value); template<> struct DBusType<int16_t> { inline static std::string GetSignature() { return DBUS_TYPE_INT16_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, int16_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, int16_t* value) { return PopValueFromReader(reader, value); } }; // uint16_t ------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, uint16_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, uint16_t* value); template<> struct DBusType<uint16_t> { inline static std::string GetSignature() { return DBUS_TYPE_UINT16_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, uint16_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, uint16_t* value) { return PopValueFromReader(reader, value); } }; // int32_t -------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, int32_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, int32_t* value); template<> struct DBusType<int32_t> { inline static std::string GetSignature() { return DBUS_TYPE_INT32_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, int32_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, int32_t* value) { return PopValueFromReader(reader, value); } }; // uint32_t ------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, uint32_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, uint32_t* value); template<> struct DBusType<uint32_t> { inline static std::string GetSignature() { return DBUS_TYPE_UINT32_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, uint32_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, uint32_t* value) { return PopValueFromReader(reader, value); } }; // int64_t -------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, int64_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, int64_t* value); template<> struct DBusType<int64_t> { inline static std::string GetSignature() { return DBUS_TYPE_INT64_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, int64_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, int64_t* value) { return PopValueFromReader(reader, value); } }; // uint64_t ------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, uint64_t value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, uint64_t* value); template<> struct DBusType<uint64_t> { inline static std::string GetSignature() { return DBUS_TYPE_UINT64_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, uint64_t value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, uint64_t* value) { return PopValueFromReader(reader, value); } }; // double --------------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, double value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, double* value); template<> struct DBusType<double> { inline static std::string GetSignature() { return DBUS_TYPE_DOUBLE_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, double value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, double* value) { return PopValueFromReader(reader, value); } }; // std::string ---------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, const std::string& value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, std::string* value); template<> struct DBusType<std::string> { inline static std::string GetSignature() { return DBUS_TYPE_STRING_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const std::string& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, std::string* value) { return PopValueFromReader(reader, value); } }; // const char* BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, const char* value); template<> struct DBusType<const char*> { inline static std::string GetSignature() { return DBUS_TYPE_STRING_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const char* value) { AppendValueToWriter(writer, value); } }; // const char[] template<> struct DBusType<const char[]> { inline static std::string GetSignature() { return DBUS_TYPE_STRING_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const char* value) { AppendValueToWriter(writer, value); } }; // dbus::ObjectPath ----------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, const dbus::ObjectPath& value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, dbus::ObjectPath* value); template<> struct DBusType<dbus::ObjectPath> { inline static std::string GetSignature() { return DBUS_TYPE_OBJECT_PATH_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const dbus::ObjectPath& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, dbus::ObjectPath* value) { return PopValueFromReader(reader, value); } }; // dbus::FileDescriptor ------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, const dbus::FileDescriptor& value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, dbus::FileDescriptor* value); template<> struct DBusType<dbus::FileDescriptor> { inline static std::string GetSignature() { return DBUS_TYPE_UNIX_FD_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const dbus::FileDescriptor& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, dbus::FileDescriptor* value) { return PopValueFromReader(reader, value); } }; // brillo::Any -------------------------------------------------------------- BRILLO_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer, const brillo::Any& value); BRILLO_EXPORT bool PopValueFromReader(dbus::MessageReader* reader, brillo::Any* value); template<> struct DBusType<brillo::Any> { inline static std::string GetSignature() { return DBUS_TYPE_VARIANT_AS_STRING; } inline static void Write(dbus::MessageWriter* writer, const brillo::Any& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, brillo::Any* value) { return PopValueFromReader(reader, value); } }; // std::vector = D-Bus ARRAY. ------------------------------------------------- template<typename T, typename ALLOC> typename std::enable_if<IsTypeSupported<T>::value>::type AppendValueToWriter( dbus::MessageWriter* writer, const std::vector<T, ALLOC>& value) { dbus::MessageWriter array_writer(nullptr); writer->OpenArray(GetDBusSignature<T>(), &array_writer); for (const auto& element : value) { // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay // binding to AppendValueToWriter() to the point of instantiation of this // template. DBusType<T>::Write(&array_writer, element); } writer->CloseContainer(&array_writer); } template<typename T, typename ALLOC> typename std::enable_if<IsTypeSupported<T>::value, bool>::type PopValueFromReader(dbus::MessageReader* reader, std::vector<T, ALLOC>* value) { dbus::MessageReader variant_reader(nullptr); dbus::MessageReader array_reader(nullptr); if (!details::DescendIntoVariantIfPresent(&reader, &variant_reader) || !reader->PopArray(&array_reader)) return false; value->clear(); while (array_reader.HasMoreData()) { T data; // Use DBusType<T>::Read() instead of PopValueFromReader() to delay // binding to PopValueFromReader() to the point of instantiation of this // template. if (!DBusType<T>::Read(&array_reader, &data)) return false; value->push_back(std::move(data)); } return true; } namespace details { // DBusArrayType<> is a helper base class for DBusType<vector<T>> that provides // GetSignature/Write/Read methods for T types that are supported by D-Bus // and not having those methods for types that are not supported by D-Bus. template<bool inner_type_supported, typename T, typename ALLOC> struct DBusArrayType { // Returns "aT", where "T" is the signature string for type T. inline static std::string GetSignature() { return GetArrayDBusSignature(GetDBusSignature<T>()); } inline static void Write(dbus::MessageWriter* writer, const std::vector<T, ALLOC>& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, std::vector<T, ALLOC>* value) { return PopValueFromReader(reader, value); } }; // Explicit specialization for unsupported type T. template<typename T, typename ALLOC> struct DBusArrayType<false, T, ALLOC> : public Unsupported {}; } // namespace details template<typename T, typename ALLOC> struct DBusType<std::vector<T, ALLOC>> : public details::DBusArrayType<IsTypeSupported<T>::value, T, ALLOC> {}; // std::pair = D-Bus STRUCT with two elements. -------------------------------- namespace details { // Helper class to get a D-Bus signature of a list of types. // For example, TupleTraits<int32_t, bool, std::string>::GetSignature() will // return "ibs". template<typename... Types> struct TupleTraits; template<typename FirstType, typename... RestOfTypes> struct TupleTraits<FirstType, RestOfTypes...> { static std::string GetSignature() { return GetDBusSignature<FirstType>() + TupleTraits<RestOfTypes...>::GetSignature(); } }; template<> struct TupleTraits<> { static std::string GetSignature() { return std::string{}; } }; } // namespace details template<typename... Types> inline std::string GetStructDBusSignature() { // Returns "(T...)", where "T..." is the signature strings for types T... return DBUS_STRUCT_BEGIN_CHAR_AS_STRING + details::TupleTraits<Types...>::GetSignature() + DBUS_STRUCT_END_CHAR_AS_STRING; } template<typename U, typename V> typename std::enable_if<IsTypeSupported<U, V>::value>::type AppendValueToWriter( dbus::MessageWriter* writer, const std::pair<U, V>& value) { dbus::MessageWriter struct_writer(nullptr); writer->OpenStruct(&struct_writer); // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay // binding to AppendValueToWriter() to the point of instantiation of this // template. DBusType<U>::Write(&struct_writer, value.first); DBusType<V>::Write(&struct_writer, value.second); writer->CloseContainer(&struct_writer); } template<typename U, typename V> typename std::enable_if<IsTypeSupported<U, V>::value, bool>::type PopValueFromReader(dbus::MessageReader* reader, std::pair<U, V>* value) { dbus::MessageReader variant_reader(nullptr); dbus::MessageReader struct_reader(nullptr); if (!details::DescendIntoVariantIfPresent(&reader, &variant_reader) || !reader->PopStruct(&struct_reader)) return false; // Use DBusType<T>::Read() instead of PopValueFromReader() to delay // binding to PopValueFromReader() to the point of instantiation of this // template. return DBusType<U>::Read(&struct_reader, &value->first) && DBusType<V>::Read(&struct_reader, &value->second); } namespace details { // DBusArrayType<> is a helper base class for DBusType<pair<U, V>> that provides // GetSignature/Write/Read methods for types that are supported by D-Bus // and not having those methods for types that are not supported by D-Bus. template<bool inner_type_supported, typename U, typename V> struct DBusPairType { // Returns "(UV)", where "U" and "V" are the signature strings for types U, V. inline static std::string GetSignature() { return GetStructDBusSignature<U, V>(); } inline static void Write(dbus::MessageWriter* writer, const std::pair<U, V>& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, std::pair<U, V>* value) { return PopValueFromReader(reader, value); } }; // Either U, or V, or both are not supported by D-Bus. template<typename U, typename V> struct DBusPairType<false, U, V> : public Unsupported {}; } // namespace details template<typename U, typename V> struct DBusType<std::pair<U, V>> : public details::DBusPairType<IsTypeSupported<U, V>::value, U, V> {}; // std::tuple = D-Bus STRUCT with arbitrary number of members. ---------------- namespace details { // TupleIterator<I, N, T...> is a helper class to iterate over all the elements // of a tuple<T...> from index I to N. TupleIterator<>::Read and ::Write methods // are called for each element of the tuple and iteration continues until I == N // in which case the specialization for I==N below stops the recursion. template<size_t I, size_t N, typename... T> struct TupleIterator { // Tuple is just a convenience alias to a tuple containing elements of type T. using Tuple = std::tuple<T...>; // ValueType is the type of the element at index I. using ValueType = typename std::tuple_element<I, Tuple>::type; // Write the tuple element at index I to D-Bus message. static void Write(dbus::MessageWriter* writer, const Tuple& value) { // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay // binding to AppendValueToWriter() to the point of instantiation of this // template. DBusType<ValueType>::Write(writer, std::get<I>(value)); TupleIterator<I + 1, N, T...>::Write(writer, value); } // Read the tuple element at index I from D-Bus message. static bool Read(dbus::MessageReader* reader, Tuple* value) { // Use DBusType<T>::Read() instead of PopValueFromReader() to delay // binding to PopValueFromReader() to the point of instantiation of this // template. return DBusType<ValueType>::Read(reader, &std::get<I>(*value)) && TupleIterator<I + 1, N, T...>::Read(reader, value); } }; // Specialization to end the iteration when the index reaches the last element. template<size_t N, typename... T> struct TupleIterator<N, N, T...> { using Tuple = std::tuple<T...>; static void Write(dbus::MessageWriter* /* writer */, const Tuple& /* value */) {} static bool Read(dbus::MessageReader* /* reader */, Tuple* /* value */) { return true; } }; } // namespace details template<typename... T> typename std::enable_if<IsTypeSupported<T...>::value>::type AppendValueToWriter( dbus::MessageWriter* writer, const std::tuple<T...>& value) { dbus::MessageWriter struct_writer(nullptr); writer->OpenStruct(&struct_writer); details::TupleIterator<0, sizeof...(T), T...>::Write(&struct_writer, value); writer->CloseContainer(&struct_writer); } template<typename... T> typename std::enable_if<IsTypeSupported<T...>::value, bool>::type PopValueFromReader(dbus::MessageReader* reader, std::tuple<T...>* value) { dbus::MessageReader variant_reader(nullptr); dbus::MessageReader struct_reader(nullptr); if (!details::DescendIntoVariantIfPresent(&reader, &variant_reader) || !reader->PopStruct(&struct_reader)) return false; return details::TupleIterator<0, sizeof...(T), T...>::Read(&struct_reader, value); } namespace details { // DBusTupleType<> is a helper base class for DBusType<tuple<T...>> that // provides GetSignature/Write/Read methods for types that are supported by // D-Bus and not having those methods for types that are not supported by D-Bus. template<bool inner_type_supported, typename... T> struct DBusTupleType { // Returns "(T...)", where "T..." are the signature strings for types T... inline static std::string GetSignature() { return GetStructDBusSignature<T...>(); } inline static void Write(dbus::MessageWriter* writer, const std::tuple<T...>& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, std::tuple<T...>* value) { return PopValueFromReader(reader, value); } }; // Some/all of types T... are not supported by D-Bus. template<typename... T> struct DBusTupleType<false, T...> : public Unsupported {}; } // namespace details template<typename... T> struct DBusType<std::tuple<T...>> : public details::DBusTupleType<IsTypeSupported<T...>::value, T...> {}; // std::map = D-Bus ARRAY of DICT_ENTRY. -------------------------------------- template<typename KEY, typename VALUE, typename PRED, typename ALLOC> typename std::enable_if<IsTypeSupported<KEY, VALUE>::value>::type AppendValueToWriter(dbus::MessageWriter* writer, const std::map<KEY, VALUE, PRED, ALLOC>& value) { dbus::MessageWriter dict_writer(nullptr); writer->OpenArray(details::GetDBusDictEntryType<KEY, VALUE>(), &dict_writer); for (const auto& pair : value) { dbus::MessageWriter entry_writer(nullptr); dict_writer.OpenDictEntry(&entry_writer); // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay // binding to AppendValueToWriter() to the point of instantiation of this // template. DBusType<KEY>::Write(&entry_writer, pair.first); DBusType<VALUE>::Write(&entry_writer, pair.second); dict_writer.CloseContainer(&entry_writer); } writer->CloseContainer(&dict_writer); } template<typename KEY, typename VALUE, typename PRED, typename ALLOC> typename std::enable_if<IsTypeSupported<KEY, VALUE>::value, bool>::type PopValueFromReader(dbus::MessageReader* reader, std::map<KEY, VALUE, PRED, ALLOC>* value) { dbus::MessageReader variant_reader(nullptr); dbus::MessageReader array_reader(nullptr); if (!details::DescendIntoVariantIfPresent(&reader, &variant_reader) || !reader->PopArray(&array_reader)) return false; value->clear(); while (array_reader.HasMoreData()) { dbus::MessageReader dict_entry_reader(nullptr); if (!array_reader.PopDictEntry(&dict_entry_reader)) return false; KEY key; VALUE data; // Use DBusType<T>::Read() instead of PopValueFromReader() to delay // binding to PopValueFromReader() to the point of instantiation of this // template. if (!DBusType<KEY>::Read(&dict_entry_reader, &key) || !DBusType<VALUE>::Read(&dict_entry_reader, &data)) return false; value->emplace(std::move(key), std::move(data)); } return true; } namespace details { // DBusArrayType<> is a helper base class for DBusType<map<K, V>> that provides // GetSignature/Write/Read methods for T types that are supported by D-Bus // and not having those methods for types that are not supported by D-Bus. template<bool inner_types_supported, typename KEY, typename VALUE, typename PRED, typename ALLOC> struct DBusMapType { // Returns "a{KV}", where "K" and "V" are the signature strings for types // KEY/VALUE. inline static std::string GetSignature() { return GetArrayDBusSignature(GetDBusDictEntryType<KEY, VALUE>()); } inline static void Write(dbus::MessageWriter* writer, const std::map<KEY, VALUE, PRED, ALLOC>& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, std::map<KEY, VALUE, PRED, ALLOC>* value) { return PopValueFromReader(reader, value); } }; // Types KEY, VALUE or both are not supported by D-Bus. template<typename KEY, typename VALUE, typename PRED, typename ALLOC> struct DBusMapType<false, KEY, VALUE, PRED, ALLOC> : public Unsupported {}; } // namespace details template<typename KEY, typename VALUE, typename PRED, typename ALLOC> struct DBusType<std::map<KEY, VALUE, PRED, ALLOC>> : public details::DBusMapType<IsTypeSupported<KEY, VALUE>::value, KEY, VALUE, PRED, ALLOC> {}; // google::protobuf::MessageLite = D-Bus ARRAY of BYTE ------------------------ inline void AppendValueToWriter(dbus::MessageWriter* writer, const google::protobuf::MessageLite& value) { writer->AppendProtoAsArrayOfBytes(value); } inline bool PopValueFromReader(dbus::MessageReader* reader, google::protobuf::MessageLite* value) { return reader->PopArrayOfBytesAsProto(value); } // is_protobuf_t<T> is a helper type trait to determine if type T derives from // google::protobuf::MessageLite. template<typename T> using is_protobuf = std::is_base_of<google::protobuf::MessageLite, T>; // Specialize DBusType<T> for classes that derive from protobuf::MessageLite. // Here we perform a partial specialization of DBusType<T> only for types // that derive from google::protobuf::MessageLite. This is done by employing // the second template parameter in DBusType and this basically relies on C++ // SFINAE rules. "typename std::enable_if<is_protobuf<T>::value>::type" will // evaluate to "void" for classes T that descend from MessageLite and will be // an invalid construct for other types/classes which will automatically // remove this particular specialization from name resolution context. template<typename T> struct DBusType<T, typename std::enable_if<is_protobuf<T>::value>::type> { inline static std::string GetSignature() { return GetDBusSignature<std::vector<uint8_t>>(); } inline static void Write(dbus::MessageWriter* writer, const T& value) { AppendValueToWriter(writer, value); } inline static bool Read(dbus::MessageReader* reader, T* value) { return PopValueFromReader(reader, value); } }; //---------------------------------------------------------------------------- // AppendValueToWriterAsVariant<T>(dbus::MessageWriter* writer, const T& value) // Write the |value| of type T to D-Bus message as a VARIANT. // This overload is provided only if T is supported by D-Bus. template<typename T> typename std::enable_if<IsTypeSupported<T>::value>::type AppendValueToWriterAsVariant(dbus::MessageWriter* writer, const T& value) { std::string data_type = GetDBusSignature<T>(); dbus::MessageWriter variant_writer(nullptr); writer->OpenVariant(data_type, &variant_writer); // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay // binding to AppendValueToWriter() to the point of instantiation of this // template. DBusType<T>::Write(&variant_writer, value); writer->CloseContainer(&variant_writer); } // Special case: do not allow to write a Variant containing a Variant. // Just redirect to normal AppendValueToWriter(). inline void AppendValueToWriterAsVariant(dbus::MessageWriter* writer, const brillo::Any& value) { return AppendValueToWriter(writer, value); } //---------------------------------------------------------------------------- // PopVariantValueFromReader<T>(dbus::MessageWriter* writer, T* value) // Reads a Variant containing the |value| of type T from D-Bus message. // Note that the generic PopValueFromReader<T>(...) can do this too. // This method is provided for two reasons: // 1. For API symmetry with AppendValueToWriter/AppendValueToWriterAsVariant. // 2. To be used when it is important to assert that the data was sent // specifically as a Variant. // This overload is provided only if T is supported by D-Bus. template<typename T> typename std::enable_if<IsTypeSupported<T>::value, bool>::type PopVariantValueFromReader(dbus::MessageReader* reader, T* value) { dbus::MessageReader variant_reader(nullptr); if (!reader->PopVariant(&variant_reader)) return false; // Use DBusType<T>::Read() instead of PopValueFromReader() to delay // binding to PopValueFromReader() to the point of instantiation of this // template. return DBusType<T>::Read(&variant_reader, value); } // Special handling of request to read a Variant of Variant. inline bool PopVariantValueFromReader(dbus::MessageReader* reader, Any* value) { return PopValueFromReader(reader, value); } } // namespace dbus_utils } // namespace brillo #endif // LIBBRILLO_BRILLO_DBUS_DATA_SERIALIZATION_H_