Cleanup

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>
 
 namespace Communication
 {
   extern const std::wstring pipeName;
 
   enum ProcType : uint32_t {
     PROC_MATCHES,
     PROC_GET_ELEMHIDE_SELECTORS,
     PROC_AVAILABLE_SUBSCRIPTIONS,
     PROC_LISTED_SUBSCRIPTIONS,
     PROC_SET_SUBSCRIPTION,
     PROC_UPDATE_ALL_SUBSCRIPTIONS,
     PROC_GET_EXCEPTION_DOMAINS,
     PROC_IS_WHITELISTED_URL,
     PROC_ADD_FILTER,
     PROC_REMOVE_FILTER,
+    PROC_SET_PREF,
+    PROC_GET_PREF
   };
   enum ValueType : uint32_t {
     TYPE_PROC, TYPE_STRING, TYPE_WSTRING, TYPE_INT64, TYPE_INT32, TYPE_BOOL
   };
   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=(const InputBuffer& copy) 
+    { 
+      hasType = copy.hasType; 
+      buffer = std::istringstream(copy.buffer.str()); 
+      currentType = copy.currentType; 
+      return *this; 
+    }
+    ValueType GetType();
   private:
     std::istringstream buffer;
     ValueType currentType;
     bool hasType;
 
     void CheckType(ValueType expectedType);
 
     template<class T>
     InputBuffer& ReadString(T& value, ValueType expectedType)
     {
@@ skipping 18 matching lines @@
       ReadBinary(value);
       return *this;
     }
 
     template<class T>
     void ReadBinary(T& value)
     {
       buffer.read(reinterpret_cast<char*>(&value), sizeof(T));
       if (buffer.fail())
         throw new std::runtime_error("Unexpected end of input buffer");
+      hasType = false;
     }
   };
 
   class OutputBuffer
   {
   public:
     OutputBuffer() {}
 
     // Explicit copy constructor to allow returning OutputBuffer by value
     OutputBuffer(const OutputBuffer& copy) : buffer(copy.buffer.str()) {}
@@ skipping 68 matching lines @@
 
     InputBuffer ReadMessage();
     void WriteMessage(OutputBuffer& message);
 
   protected:
     HANDLE pipe;
   };
 }
 
 #endif