Issue 1794 - add handling of std::vector<std::string> by Communication::{Input,Output}Buffer

src/shared/Communication.h

 #ifndef COMMUNICATION_H
 #define COMMUNICATION_H
 
 #include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <stdint.h>
 #include <string>
 #include <vector>
 #include <Windows.h>
@@ skipping 20 matching lines @@
     PROC_SET_PREF,
     PROC_GET_PREF,
     PROC_IS_FIRST_RUN_ACTION_NEEDED,
     PROC_CHECK_FOR_UPDATES,
     PROC_GET_DOCUMENTATION_LINK,
     PROC_TOGGLE_PLUGIN_ENABLED,
     PROC_GET_HOST,
     PROC_COMPARE_VERSIONS
   };
   enum ValueType : uint32_t {
-    TYPE_PROC, TYPE_STRING, TYPE_WSTRING, TYPE_INT64, TYPE_INT32, TYPE_BOOL
+    TYPE_PROC, TYPE_STRING, TYPE_WSTRING, TYPE_INT64, TYPE_INT32, TYPE_BOOL, TYPE_STRINGS

[Eric, 2015/01/13 16:20:45]

We should use TYPE_WSTRINGS.

The string type used in the filter code is std::wstring (that is, where the
conversion away from CString is complete). It will be simpler to transfer the
type used in the plugin and do the conversion in the engine.

If you think we will need both TYPE_STRINGS and TYPE_WSTRINGS, you can do it
analogously to how TYPE_STRING and TYPE_WSTRING are already working.

[sergei, 2015/01/27 15:28:39]

I'm confused, we recently accepted https://issues.adblockplus.org/ticket/715 . I
guess that the direction is that we should not work with std::wstring on the
engine side, at least in the messages to communicate between Addon and Engine.
So, I guess we don't need a version for std::wstring.

   };
   typedef uint32_t SizeType;
 
   class InputBuffer
   {
   public:
     InputBuffer() : buffer(), hasType(false) {}
     InputBuffer(const std::string& data) : buffer(data), hasType(false) {}
     InputBuffer(const InputBuffer& copy) 
     { 
       hasType = copy.hasType; 
       buffer = std::istringstream(copy.buffer.str()); 
       currentType = copy.currentType; 
     }
     InputBuffer& operator>>(ProcType& value) { return Read(value, TYPE_PROC); }
     InputBuffer& operator>>(std::string& value) { return ReadString(value, TYPE_STRING); }
     InputBuffer& operator>>(std::wstring& value) { return ReadString(value, TYPE_WSTRING); }
     InputBuffer& operator>>(int64_t& value) { return Read(value, TYPE_INT64); }
     InputBuffer& operator>>(int32_t& value) { return Read(value, TYPE_INT32); }
     InputBuffer& operator>>(bool& value) { return Read(value, TYPE_BOOL); }
+    InputBuffer& operator>>(std::vector<std::string>& value) { return ReadStrings(value); }
     InputBuffer& operator=(const InputBuffer& copy) 
     { 
       hasType = copy.hasType; 
       buffer = std::istringstream(copy.buffer.str()); 
       currentType = copy.currentType; 
       return *this; 
     }
     ValueType GetType();
   private:
     std::istringstream buffer;
@@ skipping 12 matching lines @@
 
       std::auto_ptr<T::value_type> data(new T::value_type[length]);
       buffer.read(reinterpret_cast<char*>(data.get()), sizeof(T::value_type) * length);
       if (buffer.fail())
         throw new std::runtime_error("Unexpected end of input buffer");
 
       value.assign(data.get(), length);
       return *this;
     }
 
+    InputBuffer& ReadStrings(std::vector<std::string>& value)

[Eric, 2015/01/13 16:20:45]

This should be a template function parallel to ReadString() immediately above.

+    {
+      value.clear();
+      CheckType(ValueType::TYPE_STRINGS);
+
+      SizeType length;
+      ReadBinary(length);
+      value.resize(length);
+      for (SizeType i = 0; i < length; ++i)
+      {
+        operator>>(value[i]);
+      }
+      return *this;
+    }
+
     template<class T>
     InputBuffer& Read(T& value, ValueType expectedType)
     {
       CheckType(expectedType);
       ReadBinary(value);
       return *this;
     }
 
     template<class T>
     void ReadBinary(T& value)
@@ skipping 16 matching lines @@
     std::string Get()
     {
       return buffer.str();
     }
     OutputBuffer& operator<<(ProcType value) { return Write(value, TYPE_PROC); }
     OutputBuffer& operator<<(const std::string& value) { return WriteString(value, TYPE_STRING); }
     OutputBuffer& operator<<(const std::wstring& value) { return WriteString(value, TYPE_WSTRING); }
     OutputBuffer& operator<<(int64_t value) { return Write(value, TYPE_INT64); }
     OutputBuffer& operator<<(int32_t value) { return Write(value, TYPE_INT32); }
     OutputBuffer& operator<<(bool value) { return Write(value, TYPE_BOOL); }
+    OutputBuffer& operator<<(const std::vector<std::string>& value) { return WriteStrings(value); }
   private:
     std::ostringstream buffer;
 
     // Disallow copying
     const OutputBuffer& operator=(const OutputBuffer&);
 
     template<class T>
     OutputBuffer& WriteString(const T& value, ValueType type)
     {
       WriteBinary(type);
 
       SizeType length = static_cast<SizeType>(value.size());
       WriteBinary(length);
 
       buffer.write(reinterpret_cast<const char*>(value.c_str()), sizeof(T::value_type) * length);
       if (buffer.fail())
         throw new std::runtime_error("Unexpected error writing to output buffer");
 
       return *this;
     }
 
+    OutputBuffer& WriteStrings(const std::vector<std::string>& value)
+    {
+      WriteBinary(ValueType::TYPE_STRINGS);
+      WriteBinary(static_cast<SizeType>(value.size()));
+      for (const auto& str : value)
+      {
+        operator<<(str);
+      }
+      return *this;
+    }
+
     template<class T>
     OutputBuffer& Write(const T value, ValueType type)
     {
       WriteBinary(type);
       WriteBinary(value);
       return *this;
     }
 
     template<class T>
     void WriteBinary(const T& value)
@@ skipping 32 matching lines @@
 
     InputBuffer ReadMessage();
     void WriteMessage(OutputBuffer& message);
 
   protected:
     HANDLE pipe;
   };
 }
 
 #endif