Working on fields class for the repeated fields class.

generator/Header_Template.h

@@ -11,14 +11,7 @@ enum {{ _enum.name }}
 class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
 {
   public:
-    {{ msg.name }}() :
-        {% for field in msg.fields() %}
-        {{field.variable_name}}({{field.default_value}}){{"," if not loop.last}}
-        {% endfor %}
-    {
-
-    };
-
+    {{ msg.name }}() = default;
     ~{{ msg.name }}() override = default;
 
     {% for enum in msg.nested_enums() %}
@@ -30,7 +23,7 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
     {% if field.of_type_message %}
     inline void clear_{{field.name}}() { {{field.variable_name}}.clear(); };
     {% else %}
-    inline void clear_{{field.name}}() { {{field.variable_name}} = {{field.default_value}}; };
+    inline void clear_{{field.name}}() { {{field.variable_name}}.set({{field.default_value}}); };
     {% endif %}
     inline void set_{{field.name}}(const {{field.type}}& value) { {{field.variable_name}} = value; }
     inline const {{field.type}}& get_{{field.name}}() const { return {{field.variable_name}}; }
@@ -55,7 +48,7 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
         result = result && {{field.variable_name}}.serialize(buffer);
       }
       {% else %}
-      if(({{field.default_value}} != {{field.variable_name}}) && result)
+      if(({{field.default_value}} != {{field.variable_name}}.get()) && result)
       {
         result = ::EmbeddedProto::WireFormatter::{{field.serialization_func}}({{field.variable_id_name}}, {{field.variable_name}}, buffer);
       }
@@ -133,6 +126,7 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
 {% if messages %}
 #include <MessageInterface.h>
 #include <WireFormatter.h>
+#include <Fields.h>
 #include <MessageSizeCalculator.h>
 #include <ReadBufferSection.h>
 {% endif %}

generator/protoc-gen-eams.py

@@ -45,21 +45,21 @@ class FieldTemplateParameters:
                              FieldDescriptorProto.TYPE_SINT32:   "0",
                              FieldDescriptorProto.TYPE_SINT64:   "0"}
 
-    type_to_cpp_type = {FieldDescriptorProto.TYPE_DOUBLE:   "double",
-                        FieldDescriptorProto.TYPE_FLOAT:    "float",
-                        FieldDescriptorProto.TYPE_INT64:    "int64_t",
-                        FieldDescriptorProto.TYPE_UINT64:   "uint64_t",
-                        FieldDescriptorProto.TYPE_INT32:    "int32_t",
-                        FieldDescriptorProto.TYPE_FIXED64:  "uint64_t",
-                        FieldDescriptorProto.TYPE_FIXED32:  "uint32_t",
+    type_to_cpp_type = {FieldDescriptorProto.TYPE_DOUBLE:   "EmbeddedProto::doublefixed",
+                        FieldDescriptorProto.TYPE_FLOAT:    "EmbeddedProto::floatfixed",
+                        FieldDescriptorProto.TYPE_INT64:    "EmbeddedProto::int64",
+                        FieldDescriptorProto.TYPE_UINT64:   "EmbeddedProto::uint64",
+                        FieldDescriptorProto.TYPE_INT32:    "EmbeddedProto::int32",
+                        FieldDescriptorProto.TYPE_FIXED64:  "EmbeddedProto::fixed64",
+                        FieldDescriptorProto.TYPE_FIXED32:  "EmbeddedProto::fixed32",
                         FieldDescriptorProto.TYPE_BOOL:     "bool",
                         FieldDescriptorProto.TYPE_STRING:   "TODO",     # TODO
                         FieldDescriptorProto.TYPE_BYTES:    "TODO",     # TODO
-                        FieldDescriptorProto.TYPE_UINT32:   "uint32_t",
-                        FieldDescriptorProto.TYPE_SFIXED32: "int32_t",
-                        FieldDescriptorProto.TYPE_SFIXED64: "int64_t",
-                        FieldDescriptorProto.TYPE_SINT32:   "int32_t",
-                        FieldDescriptorProto.TYPE_SINT64:   "int64_t"}
+                        FieldDescriptorProto.TYPE_UINT32:   "EmbeddedProto::uint32",
+                        FieldDescriptorProto.TYPE_SFIXED32: "EmbeddedProto::sfixed32",
+                        FieldDescriptorProto.TYPE_SFIXED64: "EmbeddedProto::sfixed64",
+                        FieldDescriptorProto.TYPE_SINT32:   "EmbeddedProto::sint32",
+                        FieldDescriptorProto.TYPE_SINT64:   "EmbeddedProto::sint64"}
 
     type_to_wire_type = {FieldDescriptorProto.TYPE_INT32:    "VARINT",
                          FieldDescriptorProto.TYPE_INT64:    "VARINT",

src/Fields.h

@@ -0,0 +1,134 @@
+#ifndef _FIELDS_H_
+#define _FIELDS_H_
+
+#include "WireFormatter.h"
+#include "WriteBufferInterface.h"
+#include "ReadBufferInterface.h"
+
+namespace EmbeddedProto 
+{
+
+
+  class Field 
+  {
+    public:
+      Field();
+      virtual ~Field() = default;
+  };
+
+  template<class TYPE>
+  class FieldTemplate : public Field
+  {
+    public:
+      FieldTemplate() = default;
+      ~FieldTemplate() override = default;
+
+      void set(const TYPE& v) { value_ = v; }      
+      void set(const TYPE&& v) { value_ = v; }
+      void operator=(const TYPE& v) { value_ = v; }
+      void operator=(const TYPE&& v) { value_ = v; }
+
+      TYPE& get() const { return value_; }
+      TYPE& get() { return value_; }
+
+    private:
+      TYPE value_;
+  };
+
+  class int32 : public FieldTemplate<int32_t> { };      
+  class int64 : public FieldTemplate<int64_t> { };      
+  class uint32 : public FieldTemplate<uint32_t> { };    
+  class uint64 : public FieldTemplate<uint64_t> { };    
+  class sint32 : public FieldTemplate<uint32_t> { };    
+  class sint64 : public FieldTemplate<uint64_t> { };    
+  class boolean : public FieldTemplate<bool> { };
+  // TODO enum
+  class fixed32 : public FieldTemplate<uint32_t> { };   
+  class fixed64 : public FieldTemplate<uint64_t> { };   
+  class sfixed32 : public FieldTemplate<int32_t> { };   
+  class sfixed64 : public FieldTemplate<int64_t> { };   
+  class floatfixed : public FieldTemplate<float> { };   
+  class doublefixed : public FieldTemplate<double> { }; 
+
+  bool serialize(uint32_t field_number, int32& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, int64& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, uint32& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeUInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, uint64& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeUInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, sint32& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeSInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, sint64& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeSInt(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, bool x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeBool(field_number, x, buffer); }
+
+  bool serialize(uint32_t field_number, fixed32& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeFixed(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, fixed64& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeFixed(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, sfixed32& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeSFixed(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, sfixed64& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeSFixed(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, floatfixed& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeFloat(field_number, x.get(), buffer); }
+
+  bool serialize(uint32_t field_number, doublefixed& x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeDouble(field_number, x.get(), buffer); }
+
+
+
+  bool deserialize(int32& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeInt(buffer, x.get()); }
+
+  bool deserialize(int64& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeInt(buffer, x.get()); }
+
+  bool deserialize(uint32& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeUInt(buffer, x.get()); }
+
+  bool deserialize(uint64& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeUInt(buffer, x.get()); }
+
+  bool deserialize(sint32& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeSInt(buffer, x.get()); }
+
+  bool deserialize(sint64& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeSInt(buffer, x.get()); }
+
+  bool deserialize(bool x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeBool(buffer, x); }
+
+  bool deserialize(fixed32& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeFixed(buffer, x.get()); }
+
+  bool deserialize(fixed64& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeFixed(buffer, x.get()); }
+
+  bool deserialize(sfixed32& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeSFixed(buffer, x.get()); }
+
+  bool deserialize(sfixed64& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeSFixed(buffer, x.get()); }
+
+  bool deserialize(floatfixed& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeFloat(buffer, x.get()); }
+
+  bool deserialize(doublefixed& x, ReadBufferInterface& buffer) 
+  { return WireFormatter::DeserializeDouble(buffer, x.get()); }
+
+} // End of namespace EmbeddedProto.
+#endif