Merge lp:~thomas-voss/dbus-cpp/switch_to_uint8_for_handling_byte_types into lp:dbus-cpp

[Thomas Voß]

Switch type for ArgumentType::byte to std::uint8_t as per DBus spec.

Switch type for ArgumentType::byte to std::uint8_t as per DBus spec.

Unmerged revisions

=== modified file 'examples/ofono/main.cpp'
--- examples/ofono/main.cpp	2014-01-05 18:58:19 +0000
+++ examples/ofono/main.cpp	2014-01-20 22:13:41 +0000
@@ -55,7 +55,7 @@
                 return "IncomingMessage";
             };
             typedef MessageManager Interface;
-            typedef std::tuple<std::string, std::map<std::string, dbus::types::Variant<dbus::types::Any>>> ArgumentType;
+            typedef std::tuple<std::string, std::map<std::string, dbus::types::Variant>> ArgumentType;
         };
     };
 };
@@ -70,7 +70,7 @@
                 return "CallAdded";
             };
             typedef VoiceCallManager Interface;
-            typedef std::tuple<dbus::types::ObjectPath, std::map<std::string, dbus::types::Variant<dbus::types::Any>>> ArgumentType;
+            typedef std::tuple<dbus::types::ObjectPath, std::map<std::string, dbus::types::Variant>> ArgumentType;
         };
     };
 };

=== modified file 'examples/upower/main.cpp'
--- examples/upower/main.cpp	2013-11-27 18:57:42 +0000
+++ examples/upower/main.cpp	2014-01-20 22:13:41 +0000
@@ -58,7 +58,7 @@
     auto upower_object = upower->object_for_path(dbus::types::ObjectPath("/core/UPower"));
 
     auto all_properties = upower_object->get_all_properties<core::UPower>();
-    std::for_each(all_properties.begin(), all_properties.end(), [](const std::pair<const std::string, dbus::types::Variant<dbus::types::Any>>& pair)
+    std::for_each(all_properties.begin(), all_properties.end(), [](const std::pair<const std::string, dbus::types::Variant>& pair)
     {
         std::cout << pair.first << std::endl;
     });
@@ -181,7 +181,7 @@
         std::cout << "\tRecallUrl: " << device->get_property<core::UPower::Device::Properties::RecallUrl>()->get() << std::endl;
         std::cout << "-----------------------------------------------------------------------------------" << std::endl;
         auto properties = device->get_all_properties<core::UPower::Device>();
-        std::for_each(properties.begin(), properties.end(), [](const std::pair<const std::string, dbus::types::Variant<dbus::types::Any>>& pair)
+        std::for_each(properties.begin(), properties.end(), [](const std::pair<const std::string, dbus::types::Variant>& pair)
         {
             std::cout << "\t" << pair.first << std::endl;
         });

=== modified file 'include/core/dbus/codec.h'
--- include/core/dbus/codec.h	2014-01-05 18:58:19 +0000
+++ include/core/dbus/codec.h	2014-01-20 22:13:41 +0000
@@ -292,30 +292,6 @@
 };
 
 /**
- * @brief Template specialization for variant argument types.
- */
-template<typename T>
-struct Codec<types::Variant<T>>
-{
-    inline static void encode_argument(Message::Writer& out, const types::Variant<T>& value)
-    {
-        auto vw = out.open_variant(
-                    types::Signature(helper::TypeMapper<T>::signature()));
-        {
-            Codec<T>::encode_argument(vw, value.get());
-        }
-        out.close_variant(std::move(vw));
-    }
-
-    inline static void decode_argument(Message::Reader& in, types::Variant<T>& value)
-    {
-        auto vr = in.pop_variant(); T inner_value;
-        Codec<T>::decode_argument(vr, inner_value);
-        value.set(inner_value);
-    }
-};
-
-/**
  * @brief Template specialization for any argument types.
  */
 template<>

=== modified file 'include/core/dbus/helper/type_mapper.h'
--- include/core/dbus/helper/type_mapper.h	2013-11-27 18:57:42 +0000
+++ include/core/dbus/helper/type_mapper.h	2014-01-20 22:13:41 +0000
@@ -20,10 +20,10 @@
 
 #include <core/dbus/argument_type.h>
 
+#include <core/dbus/types/any.h>
 #include <core/dbus/types/object_path.h>
 #include <core/dbus/types/signature.h>
 #include <core/dbus/types/unix_fd.h>
-#include <core/dbus/types/variant.h>
 
 #include <cstdint>
 
@@ -37,6 +37,10 @@
 {
 namespace dbus
 {
+namespace types
+{
+class Variant;
+}
 namespace helper
 {
 
@@ -54,7 +58,7 @@
 template<>
 struct DBusTypeMapper<ArgumentType::byte>
 {
-    typedef int8_t Type;
+    typedef uint8_t Type;
 };
 
 template<>
@@ -395,8 +399,8 @@
     }
 };
 
-template<typename T>
-struct TypeMapper<types::Variant<T>>
+template<>
+struct TypeMapper<types::Variant>
 {
     constexpr inline static ArgumentType type_value()
     {
@@ -413,7 +417,7 @@
 
     inline static std::string signature()
     {
-        return DBUS_TYPE_VARIANT_AS_STRING + TypeMapper<T>::signature();
+        return DBUS_TYPE_VARIANT_AS_STRING;
     }
 };
 }

=== modified file 'include/core/dbus/impl/object.h'
--- include/core/dbus/impl/object.h	2014-01-14 13:01:38 +0000
+++ include/core/dbus/impl/object.h	2014-01-20 22:13:41 +0000
@@ -80,8 +80,7 @@
                 msg,
                 Method::default_timeout());
     
-    Result<ResultType> result = Result<ResultType>::from_message(reply);
-    return result;
+    return std::move(Result<ResultType>::from_message(reply));
 }
 
 template<typename Method, typename ResultType, typename... Args>
@@ -175,13 +174,15 @@
 }
 
 template<typename Interface>
-inline std::map<std::string, types::Variant<types::Any>>
+inline std::map<std::string, types::Variant>
 Object::get_all_properties()
 {
-    return invoke_method_synchronously<
-        interfaces::Properties::GetAll,
-        std::map<std::string, types::Variant<types::Any>>
-        >(traits::Service<Interface>::interface_name()).value();
+    return
+        std::move(
+                invoke_method_synchronously<
+                    interfaces::Properties::GetAll,
+                    std::map<std::string, types::Variant>
+                >(traits::Service<Interface>::interface_name()).value());
 }
 
 template<typename SignalDescription>
@@ -311,10 +312,10 @@
 inline void Object::on_properties_changed(
         const interfaces::Properties::Signals::PropertiesChanged::ArgumentType& arg)
 {
-    auto interface = std::get<0>(arg);
-    auto changed_values = std::get<1>(arg);
+    const auto& interface = std::get<0>(arg);
+    const auto& changed_values = std::get<1>(arg);
 
-    for (auto value : changed_values)
+    for (const auto& value : changed_values)
     {
         auto it = property_changed_vtable.find(std::make_tuple(interface, value.first));
         if (it != property_changed_vtable.end())

=== modified file 'include/core/dbus/impl/property.h'
--- include/core/dbus/impl/property.h	2014-01-13 07:50:41 +0000
+++ include/core/dbus/impl/property.h	2014-01-20 22:13:41 +0000
@@ -29,8 +29,8 @@
     if (parent->is_stub())
     {
         Super::mutable_get() = parent->invoke_method_synchronously<
-                interfaces::Properties::Get,
-                types::Variant<typename PropertyType::ValueType>
+                    interfaces::Properties::Get,
+                    types::TypedVariant<typename Property<PropertyType>::ValueType>
                 >(interface, name).value().get();
     }
     return Super::get();
@@ -48,9 +48,9 @@
         }
 
         parent->invoke_method_synchronously<
-                interfaces::Properties::Set,
-                void
-                >(interface, name, types::Variant<ValueType>(new_value));
+                    interfaces::Properties::Set,
+                    void
+                >(interface, name, types::TypedVariant<ValueType>(new_value));
     }
 
     Super::set(new_value);
@@ -113,7 +113,7 @@
 Property<PropertyType>::handle_get(const Message::Ptr& msg)
 {
     auto reply = Message::make_method_return(msg);
-    reply->writer() << types::Variant<ValueType>(Super::get());
+    reply->writer() << types::TypedVariant<ValueType>(Super::get());
 
     parent->parent->get_connection()->send(reply);
 }
@@ -133,7 +133,7 @@
         return;
     }
 
-    std::string s; types::Variant<ValueType> value;
+    std::string s; types::TypedVariant<ValueType> value;
     try
     {
         msg->reader() >> s >> s >> value;
@@ -156,12 +156,11 @@
 
 template<typename PropertyType>
 void
-Property<PropertyType>::handle_changed(const types::Variant<types::Any>& arg)
+Property<PropertyType>::handle_changed(const types::Variant& arg)
 {
     try
     {
-        typename PropertyType::ValueType value;
-        arg.get().reader() >> value;
+        auto value = arg.as<typename PropertyType::ValueType>();
         set(value);
     }
     catch (...)

=== modified file 'include/core/dbus/interfaces/properties.h'
--- include/core/dbus/interfaces/properties.h	2013-11-27 18:57:42 +0000
+++ include/core/dbus/interfaces/properties.h	2014-01-20 22:13:41 +0000
@@ -89,7 +89,7 @@
             typedef Properties Interface;
             typedef std::tuple<
                 std::string,
-                std::map<std::string, core::dbus::types::Variant<>>,
+                std::map<std::string, core::dbus::types::Variant>,
                 std::vector<std::string>
             > ArgumentType;
         };

=== modified file 'include/core/dbus/object.h'
--- include/core/dbus/object.h	2014-01-14 13:01:38 +0000
+++ include/core/dbus/object.h	2014-01-20 22:13:41 +0000
@@ -66,7 +66,6 @@
 {
 class Any;
 class ObjectPath;
-template<typename T>
 class Variant;
 }
 class MatchRule;
@@ -131,8 +130,8 @@
      * @brief Queries all properties in one go for the object.
      */
     template<typename Interface>
-    std::map<std::string, types::Variant<types::Any>>
-    inline get_all_properties();
+    inline std::map<std::string, types::Variant>
+    get_all_properties();
 
     /**
      * @brief Accesses a signal of the object.
@@ -203,7 +202,7 @@
     MessageRouter<PropertyKey> set_property_router;
     std::map<
         std::tuple<std::string, std::string>,
-        std::function<void(const types::Variant<types::Any>&)>
+        std::function<void(const types::Variant&)>
     > property_changed_vtable;
     std::shared_ptr<
         Signal<

=== modified file 'include/core/dbus/property.h'
--- include/core/dbus/property.h	2014-01-05 18:58:19 +0000
+++ include/core/dbus/property.h	2014-01-20 22:13:41 +0000
@@ -76,7 +76,7 @@
 
     inline void handle_get(const Message::Ptr& msg);
     inline void handle_set(const Message::Ptr& msg);
-    inline void handle_changed(const types::Variant<types::Any>& msg);
+    inline void handle_changed(const types::Variant& msg);
 
     std::shared_ptr<Object> parent;
     std::string interface;

=== modified file 'include/core/dbus/types/stl/map.h'
--- include/core/dbus/types/stl/map.h	2014-01-13 12:02:23 +0000
+++ include/core/dbus/types/stl/map.h	2014-01-20 22:13:41 +0000
@@ -76,9 +76,25 @@
 };
 }
 template<typename T, typename U>
+struct Codec<std::pair<const T, U>>
+{
+    static void encode_argument(Message::Writer& out, const std::pair<const T, U>& arg)
+    {
+        Codec<typename std::decay<T>::type>::encode_argument(out, arg.first);
+        Codec<typename std::decay<U>::type>::encode_argument(out, arg.second);
+    }
+
+    static void decode_argument(Message::Reader& in, std::pair<T, U>& arg)
+    {
+        Codec<T>::decode_argument(in, arg.first);
+        Codec<U>::decode_argument(in, arg.second);
+    }
+};
+
+template<typename T, typename U>
 struct Codec<std::pair<T, U>>
 {
-    static void encode_argument(Message::Writer& out, const std::pair<T, U>& arg)
+    static void encode_argument(Message::Writer& out, const std::pair<const T, U>& arg)
     {
         Codec<typename std::decay<T>::type>::encode_argument(out, arg.first);
         Codec<typename std::decay<U>::type>::encode_argument(out, arg.second);
@@ -100,7 +116,7 @@
                     types::Signature(
                         helper::TypeMapper<typename std::map<T, U>::value_type>::signature()));
         {
-            for (auto element : arg)
+            for (const auto& element : arg)
             {
                 auto de = aw.open_dict_entry();
                 {
@@ -128,12 +144,12 @@
             if (it == out.end())
             {
                 bool inserted = false;
-                std::tie(std::ignore, inserted) = out.insert(v);
+                std::tie(std::ignore, inserted) = out.insert(std::move(v));
                 if (!inserted)
                     throw std::runtime_error("Could not insert decoded element into map");
             } else
             {
-                it->second = v.second;
+                it->second = std::move(v.second);
             }
         }
     }

=== modified file 'include/core/dbus/types/variant.h'
--- include/core/dbus/types/variant.h	2013-11-27 18:57:42 +0000
+++ include/core/dbus/types/variant.h	2014-01-20 22:13:41 +0000
@@ -18,10 +18,15 @@
 #ifndef CORE_DBUS_TYPES_VARIANT_H_
 #define CORE_DBUS_TYPES_VARIANT_H_
 
+#include <core/dbus/codec.h>
+#include <core/dbus/message.h>
+#include <core/dbus/helper/type_mapper.h>
 #include <core/dbus/types/any.h>
+#include <core/dbus/types/signature.h>
 
 #include <cstring>
 
+#include <functional>
 #include <memory>
 #include <stdexcept>
 
@@ -31,32 +36,209 @@
 {
 namespace types
 {
-template<typename T = core::dbus::types::Any>
 class Variant
 {
-public:
-    explicit Variant(const T& value = T()) : value(value)
-    {
-    }
-
-    const T& get() const
+protected:
+    typedef std::function<void(dbus::Message::Writer&)> Encoder;
+    typedef std::function<void(dbus::Message::Reader&)> Decoder;
+
+    inline Variant(const Encoder& encoder, const types::Signature& signature)
+        : encoder(encoder),
+          decoder(),
+          signature_(signature)
+    {
+    }
+
+    inline Variant(const Decoder& decoder, const types::Signature& signature)
+        : encoder(),
+          decoder(decoder),
+          signature_(signature)
+    {
+    }
+public:
+    template<typename T>
+    static inline Variant encode(T t)
+    {
+        auto encoder = [t](dbus::Message::Writer& writer)
+        {
+            Codec<T>::encode_argument(writer, t);
+        };
+
+        return std::move(
+                    Variant(
+                        encoder,
+                        types::Signature(
+                            core::dbus::helper::TypeMapper<T>::signature())));
+    }
+
+    template<typename T>
+    static inline Variant decode(T& t)
+    {
+        auto decoder = [&t](dbus::Message::Reader& reader)
+        {
+            Codec<T>::decode_argument(reader, t);
+        };
+
+        return std::move(
+                    Variant(
+                        decoder,
+                        types::Signature(
+                            core::dbus::helper::TypeMapper<T>::signature())));
+    }
+
+    inline Variant()
+    {
+        decoder = [this](dbus::Message::Reader& reader)
+        {
+            core::dbus::Codec<types::Any>::decode_argument(reader, any);
+        };
+    }
+
+    inline Variant(const Variant& rhs) = default;
+
+    inline Variant(Variant&& rhs)
+        : encoder(std::move(rhs.encoder)),
+          decoder(std::move(rhs.decoder)),
+          any(std::move(rhs.any)),
+          signature_(std::move(rhs.signature_))
+    {
+    }
+
+    virtual ~Variant() = default;
+
+    inline Variant& operator=(Variant&& rhs)
+    {
+        encoder = std::move(rhs.encoder);
+        decoder = std::move(rhs.decoder);
+        signature_ = std::move(rhs.signature_);
+        any = std::move(rhs.any);
+
+        return *this;
+    }
+
+    virtual void decode(Message::Reader& reader)
+    {
+        if (!decoder)
+            throw std::runtime_error("Variant::decode: Missing a decoder specification.");
+
+        decoder(reader);
+    }
+
+    virtual void encode(Message::Writer& writer) const
+    {
+        if (!encoder)
+            throw std::runtime_error("Variant::encode: Missing an encoder specification.");
+
+        encoder(writer);
+    }
+
+    virtual const types::Signature& signature() const
+    {
+        return signature_;
+    }
+
+    template<typename T>
+    T as() const
+    {
+        T result;
+        any.reader() >> result;
+
+        return result;
+    }
+
+protected:
+    inline void set_encoder(const Encoder& encoder)
+    {
+        this->encoder = encoder;
+    }
+
+    inline void set_decoder(const Decoder& decoder)
+    {
+        this->decoder = decoder;
+    }
+
+    inline void set_signature(const types::Signature& signature)
+    {
+        this->signature_ = signature;
+    }
+
+private:
+    Encoder encoder;
+    Decoder decoder;
+    types::Any any;
+    types::Signature signature_;
+};
+
+template<typename T>
+class TypedVariant : public Variant
+{
+public:
+    explicit TypedVariant(const T& t = T()) : value(t)
+    {
+        auto decoder = [this](dbus::Message::Reader& reader)
+        {
+            Codec<T>::decode_argument(reader, value);
+        };
+
+        auto encoder = [this](dbus::Message::Writer& writer)
+        {
+            Codec<T>::encode_argument(writer, value);
+        };
+
+        set_decoder(decoder);
+        set_encoder(encoder);
+        set_signature(types::Signature{helper::TypeMapper<T>::signature()});
+    }
+
+    inline const T& get() const
     {
         return value;
     }
 
-    void set(const T& new_value)
+    inline void set(const T& t)
     {
-        value = new_value;
+        value = t;
     }
 
-    bool operator==(const Variant<T>& rhs) const
-    {
-        return value == rhs.value;
-    }
 private:
     T value;
 };
 }
+/**
+ * @brief Template specialization for variant argument types.
+ */
+template<>
+struct Codec<types::Variant>
+{
+    inline static void encode_argument(Message::Writer& out, const types::Variant& variant)
+    {
+        auto vw = out.open_variant(variant.signature());
+        {
+            variant.encode(vw);
+        }
+        out.close_variant(std::move(vw));
+    }
+
+    inline static void decode_argument(Message::Reader& in, types::Variant& variant)
+    {
+        auto vr = in.pop_variant();
+        variant.decode(vr);
+    }
+};
+
+template<typename T>
+struct Codec<types::TypedVariant<T>>
+{
+    inline static void encode_argument(Message::Writer& out, const types::TypedVariant<T>& variant)
+    {
+        Codec<types::Variant>::encode_argument(out, variant);
+    }
+
+    inline static void decode_argument(Message::Reader& in, types::TypedVariant<T>& variant)
+    {
+        Codec<types::Variant>::decode_argument(in, variant);
+    }
+};
 }
 }
 #endif // CORE_DBUS_TYPES_VARIANT_H_

=== modified file 'src/core/dbus/message.cpp'
--- src/core/dbus/message.cpp	2014-01-05 18:58:19 +0000
+++ src/core/dbus/message.cpp	2014-01-20 22:13:41 +0000
@@ -477,7 +477,7 @@
     Writer w(d->msg);
     if (!dbus_message_iter_open_container(
                 std::addressof(d->iter),
-                static_cast<int>(ArgumentType::structure),
+                static_cast<int>(ArgumentType::dictionary_entry),
                 nullptr,
                 std::addressof(w.d->iter)))
         throw std::runtime_error("Problem opening container");

=== modified file 'src/core/dbus/message_p.h'
--- src/core/dbus/message_p.h	2013-11-27 18:57:42 +0000
+++ src/core/dbus/message_p.h	2014-01-20 22:13:41 +0000
@@ -20,6 +20,7 @@
 
 #include <core/dbus/message.h>
 
+#include <cstring>
 #include <sstream>
 
 namespace core

=== modified file 'tests/codec_test.cpp'
--- tests/codec_test.cpp	2014-01-05 18:58:19 +0000
+++ tests/codec_test.cpp	2014-01-20 22:13:41 +0000
@@ -18,6 +18,7 @@
 
 #include <core/dbus/codec.h>
 #include <core/dbus/dbus.h>
+#include <core/dbus/message_streaming_operators.h>
 #include <core/dbus/helper/signature.h>
 
 #include <core/dbus/types/any.h>
@@ -43,7 +44,7 @@
 TEST(Codec, BasicTypesMatchSizeAndAlignOfDBusTypes)
 {
     ::testing::StaticAssertTypeEq<dbus_bool_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::boolean>::Type>();
-    ::testing::StaticAssertTypeEq<int8_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::byte>::Type>();
+    ::testing::StaticAssertTypeEq<uint8_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::byte>::Type>();
     ::testing::StaticAssertTypeEq<int16_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::int16>::Type>();
     ::testing::StaticAssertTypeEq<uint16_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::uint16>::Type>();
     ::testing::StaticAssertTypeEq<int32_t, typename core::dbus::helper::DBusTypeMapper<core::dbus::ArgumentType::int32>::Type>();
@@ -300,10 +301,10 @@
 TEST(Variant, TypeMapperSpecializationReturnsCorrectValues)
 {
     namespace dbus = core::dbus;
-    ASSERT_EQ(dbus::ArgumentType::variant, dbus::helper::TypeMapper<dbus::types::Variant<double>>::type_value());
+    ASSERT_EQ(dbus::ArgumentType::variant, dbus::helper::TypeMapper<dbus::types::Variant>::type_value());
     ASSERT_TRUE(dbus::helper::TypeMapper<dbus::types::ObjectPath>::is_basic_type());
     ASSERT_TRUE(dbus::helper::TypeMapper<dbus::types::ObjectPath>::requires_signature());
-    ASSERT_STREQ(DBUS_TYPE_VARIANT_AS_STRING DBUS_TYPE_DOUBLE_AS_STRING, dbus::helper::TypeMapper<dbus::types::Variant<double>>::signature().c_str());
+    ASSERT_STREQ(DBUS_TYPE_VARIANT_AS_STRING, dbus::helper::TypeMapper<dbus::types::Variant>::signature().c_str());
 }
 
 TEST(Variant, EncodingAndDecodingWorksCorrectly)
@@ -311,16 +312,20 @@
     namespace dbus = core::dbus;
 
     typedef dbus::types::Struct<std::tuple<double, double, std::int32_t>> Struct;
-    Struct my_struct = Struct{std::make_tuple(42., 42., 56)};
 
-    const dbus::types::Variant<Struct> expected_value {my_struct};
+    const Struct expected_value = Struct{std::make_tuple(42., 42., 56)};
     auto msg = a_method_call();
-    auto writer = msg->writer();
-
-    ASSERT_NO_THROW(dbus::encode_argument(writer, expected_value););
-
+    {
+        auto writer = msg->writer();
+        ASSERT_NO_THROW(dbus::encode_argument(writer, dbus::types::Variant::encode(expected_value)););
+    }
     auto reader = msg->reader();
-    ASSERT_EQ(expected_value, dbus::decode_argument<dbus::types::Variant<Struct>>(reader));
+    Struct my_struct;
+    auto variant = std::move(dbus::types::Variant::decode(my_struct));
+    dbus::decode_argument<dbus::types::Variant>(
+        reader,
+        variant);
+    ASSERT_EQ(expected_value, my_struct);
 }
 
 TEST(Signature, TypeMapperSpecializationReturnsCorrectValues)
@@ -359,7 +364,7 @@
 
     {
         auto writer = msg->writer();
-        auto array = writer.open_array(dbus::types::Signature{"(sv)"});
+        auto array = writer.open_array(dbus::types::Signature{"{sv}"});
         for(unsigned int i = 0; i < 5; i++)
         {
             auto entry = array.open_dict_entry();
@@ -393,3 +398,35 @@
 
     EXPECT_EQ(5, counter);
 }
+
+TEST(Properties, DictionaryMappingToVariantsIsEncodedCorrectlyWithMap)
+{
+    namespace dbus = core::dbus;
+
+    const std::string key{"key"};
+
+    auto msg = a_method_call();
+
+    {
+        std::map<std::string, dbus::types::Variant> map;
+
+        map["key1"] = dbus::types::Variant::encode<std::uint32_t>(1);
+        map["key2"] = dbus::types::Variant::encode<std::uint32_t>(2);
+        map["key3"] = dbus::types::Variant::encode<std::uint32_t>(3);
+        map["key4"] = dbus::types::Variant::encode<std::uint32_t>(4);
+        map["key5"] = dbus::types::Variant::encode<std::uint32_t>(5);
+
+        msg->writer() << map;
+    }
+
+    auto reader = msg->reader();
+    std::map<std::string, dbus::types::Variant> map;
+    reader >> map;
+
+    EXPECT_EQ(5, map.size());
+    EXPECT_EQ(1, map.at("key1").as<std::uint32_t>());
+    EXPECT_EQ(2, map.at("key2").as<std::uint32_t>());
+    EXPECT_EQ(3, map.at("key3").as<std::uint32_t>());
+    EXPECT_EQ(4, map.at("key4").as<std::uint32_t>());
+    EXPECT_EQ(5, map.at("key5").as<std::uint32_t>());
+}

=== modified file 'tests/stl_codec_test.cpp'
--- tests/stl_codec_test.cpp	2014-01-07 15:57:23 +0000
+++ tests/stl_codec_test.cpp	2014-01-20 22:13:41 +0000
@@ -19,6 +19,8 @@
 #include <core/dbus/dbus.h>
 #include <core/dbus/message_streaming_operators.h>
 
+#include <core/dbus/types/variant.h>
+
 #include <core/dbus/types/stl/map.h>
 #include <core/dbus/types/stl/string.h>
 #include <core/dbus/types/stl/tuple.h>
@@ -66,7 +68,7 @@
 
     {
         auto writer = msg->writer();
-        auto array = writer.open_array(dbus::types::Signature{"(sv)"});
+        auto array = writer.open_array(dbus::types::Signature{"{sv}"});
         for(unsigned int i = 0; i < 5; i++)
         {
             auto entry = array.open_dict_entry();
@@ -84,7 +86,7 @@
 
     unsigned int counter = 0;
 
-    std::map<std::string, dbus::types::Variant<dbus::types::Any>> result;
+    std::map<std::string, dbus::types::Variant> result;
     msg->reader() >> result;
 
     EXPECT_EQ(5, result.size());
@@ -92,7 +94,7 @@
     for (const auto& element : result)
     {
         EXPECT_EQ(std::to_string(counter), element.first);
-        EXPECT_EQ(counter, element.second.get().reader().pop_uint32());
+        EXPECT_EQ(counter, element.second.as<std::uint32_t>());
 
         counter++;
     }