Use a proper enum type for procedures that can be called

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;
   const int bufferSize = 1024;
 
-  enum {TYPE_STRING, TYPE_WSTRING, TYPE_INT64, TYPE_INT32, TYPE_BOOL};
-  typedef int32_t ValueType;
+  enum ProcType : uint32_t {

[Felix Dahlke, 2013/06/04 06:47:32]

I can't find anything about this, but I think you said it was MSVS-only? I'd
rather have standard C++ to be honest.

We can just have a single typedef Communication::Uint or something. Just so that
we don't have to remember using uint32_t everywhere.

[Wladimir Palant, 2013/06/04 09:26:13]

It is a standard feature, see
http://en.wikipedia.org/wiki/C%2B%2B11#Strongly_typed_enumerations.
Unfortunately, the MSVC implementation is non-standard - typing is implemented
for regular enums, not enum classes (which are unsupported).

[Felix Dahlke, 2013/06/04 11:55:21]

Didn't know it's a new standard feature, in this case it's the best solution :)

As long as we have something equivalent in other compilers, we can always have
some conditional code if all else fails.

+    PROC_MATCHES,
+    PROC_GET_ELEMHIDE_SELECTORS,
+    PROC_AVAILABLE_SUBSCRIPTIONS,
+    PROC_LISTED_SUBSCRIPTIONS,
+    PROC_SET_SUBSCRIPTION,
+    PROC_UPDATE_ALL_SUBSCRIPTIONS,
+    PROC_GET_EXCEPTION_DOMAINS,
+    PROC_ADD_FILTER,
+  };
+  enum ValueType : uint32_t {
+    TYPE_PROC, TYPE_STRING, TYPE_WSTRING, TYPE_INT64, TYPE_INT32, TYPE_BOOL
+  };
   typedef uint32_t SizeType;
 
   class InputBuffer
   {
   public:
     InputBuffer(const std::string& data) : buffer(data), hasType(false) {}
+    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); }
   private:
     std::istringstream buffer;
     ValueType currentType;
     bool hasType;
 
@@ skipping 51 matching lines @@
   public:
     OutputBuffer() {}
 
     // Explicit copy constructor to allow returning OutputBuffer by value
     OutputBuffer(const OutputBuffer& copy) : buffer(copy.buffer.str()) {}
 
     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); }
   private:
     std::ostringstream buffer;
 
     // Disallow copying
     const OutputBuffer& operator=(const OutputBuffer&);
@@ skipping 46 matching lines @@
 
     InputBuffer ReadMessage();
     void WriteMessage(OutputBuffer& message);
 
   protected:
     HANDLE pipe;
   };
 }
 
 #endif