Enhance the DBus interface for peerd

dbus/property.h

 // Copyright (c) 2012 The Chromium 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 DBUS_PROPERTY_H_
 #define DBUS_PROPERTY_H_
 
 #include <map>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "dbus/dbus_export.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 
 // D-Bus objects frequently provide sets of properties accessed via a
 // standard interface of method calls and signals to obtain the current value,
@@ skipping 131 matching lines @@
   //     if (property_name == properties.version.name()) {
   //       // Handle version property changing
   //     }
   //   }
   const std::string& name() const { return name_; }
 
   // Method used by PropertySet to retrieve the value from a MessageReader,
   // no knowledge of the contained type is required, this method returns
   // true if its expected type was found, false if not.
   // Implementation provided by specialization.
-  virtual bool PopValueFromReader(MessageReader*) = 0;
+  virtual bool PopValueFromReader(MessageReader* reader) = 0;
 
   // Method used by PropertySet to append the set value to a MessageWriter,
   // no knowledge of the contained type is required.
   // Implementation provided by specialization.
   virtual void AppendSetValueToWriter(MessageWriter* writer) = 0;
 
   // Method used by test and stub implementations of dbus::PropertySet::Set
   // to replace the property value with the set value without using a
   // dbus::MessageReader.
   virtual void ReplaceValueWithSetValue() = 0;
@@ skipping 50 matching lines @@
   void RegisterProperty(const std::string& name, PropertyBase* property);
 
   // Connects property change notification signals to the object, generally
   // called immediately after the object is created and before calls to other
   // methods. Sub-classes may override to use different D-Bus signals.
   virtual void ConnectSignals();
 
   // Methods connected by ConnectSignals() and called by dbus:: when
   // a property is changed. Sub-classes may override if the property
   // changed signal provides different arguments.
-  virtual void ChangedReceived(Signal*);
+  virtual void ChangedReceived(Signal* signal);
   virtual void ChangedConnected(const std::string& interface_name,
                                 const std::string& signal_name,
                                 bool success);
 
   // Callback for Get() method, |success| indicates whether or not the
   // value could be retrived, if true the new value can be obtained by
   // calling value() on the property.
   typedef base::Callback<void(bool success)> GetCallback;
 
   // Requests an updated value from the remote object for |property|
@@ skipping 126 matching lines @@
   // request, however the new value may not be available depending on the
   // remote object.
   virtual void Set(const T& value, dbus::PropertySet::SetCallback callback) {
     set_value_ = value;
     property_set()->Set(this, callback);
   }
 
   // Method used by PropertySet to retrieve the value from a MessageReader,
   // no knowledge of the contained type is required, this method returns
   // true if its expected type was found, false if not.
-  bool PopValueFromReader(MessageReader*) override;
+  bool PopValueFromReader(MessageReader* reader) override;
 
   // Method used by PropertySet to append the set value to a MessageWriter,
   // no knowledge of the contained type is required.
   // Implementation provided by specialization.
   void AppendSetValueToWriter(MessageWriter* writer) override;
 
   // Method used by test and stub implementations of dbus::PropertySet::Set
   // to replace the property value with the set value without using a
   // dbus::MessageReader.
   void ReplaceValueWithSetValue() override {
@@ skipping 88 matching lines @@
 template <> void Property<std::vector<ObjectPath> >::AppendSetValueToWriter(
   MessageWriter* writer);
 extern template class Property<std::vector<ObjectPath> >;
 
 template <> bool Property<std::vector<uint8> >::PopValueFromReader(
   MessageReader* reader);
 template <> void Property<std::vector<uint8> >::AppendSetValueToWriter(
   MessageWriter* writer);
 extern template class Property<std::vector<uint8> >;
 
+template <>
+bool Property<std::map<std::string, std::string>>::PopValueFromReader(
+    MessageReader* reader);
+template <>
+void Property<std::map<std::string, std::string>>::AppendSetValueToWriter(
+    MessageWriter* writer);
+extern template class Property<std::map<std::string, std::string>>;
+
+template <>
+bool Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>::
+    PopValueFromReader(MessageReader* reader);
+template <>
+void Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>::
+    AppendSetValueToWriter(MessageWriter* writer);
+extern template class Property<
+    std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>;

[hashimoto, 2015/02/06 07:45:12]

It's unfortunate property.h should be changed to support this type (and any
tricky template types) :(
Anyways, it's OK as it seems this is the only available option under the current
design.

[dtapuska, 2015/02/06 15:56:01]

Acknowledged.

+
 }  // namespace dbus
 
 #endif  // DBUS_PROPERTY_H_