Various bug fixes

generator/Header_Template.h

@@ -5,6 +5,7 @@ enum {{ _enum.name }}
   {{ value.name }} = {{ value.number }}{{ "," if not loop.last }}
   {% endfor %}
 };
+
 {% endmacro %}
 
 {% macro msg_macro(msg) %}
@@ -21,14 +22,16 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
     {% for field in msg.fields() %}
     static const uint32_t {{field.variable_id_name}} = {{field.variable_id}};
     {% if field.of_type_message %}
-    inline void clear_{{field.name}}() { {{field.variable_name}}.clear(); };
-    {% else %}
-    inline void clear_{{field.name}}() { {{field.variable_name}}.set({{field.default_value}}); };
-    {% endif %}
+    inline void clear_{{field.name}}() { {{field.variable_name}}.clear(); }
     inline void set_{{field.name}}(const {{field.type}}& value) { {{field.variable_name}} = value; }
+    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}}; }
-    {% if field.of_type_message %}
     inline {{field.type}}& mutable_{{field.name}}() { return {{field.variable_name}}; }
+    {% else %}
+    inline void clear_{{field.name}}() { {{field.variable_name}}.set({{field.default_value}}); }
+    inline void set_{{field.name}}(const {{field.type}}::FIELD_TYPE& value) { {{field.variable_name}}.set(value); }
+    inline void set_{{field.name}}(const {{field.type}}::FIELD_TYPE&& value) { {{field.variable_name}}.set(value); }
+    inline const {{field.type}}::FIELD_TYPE& get_{{field.name}}() const { return {{field.variable_name}}.get(); }
     {% endif %}
 
     {% endfor %}
@@ -50,7 +53,7 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
       {% else %}
       if(({{field.default_value}} != {{field.variable_name}}.get()) && result)
       {
-        result = ::EmbeddedProto::WireFormatter::{{field.serialization_func}}({{field.variable_id_name}}, {{field.variable_name}}, buffer);
+        result = ::EmbeddedProto::{{field.serialization_func}}({{field.variable_id_name}}, {{field.variable_name}}, buffer);
       }
       {% endif %}
 
@@ -79,7 +82,7 @@ class {{ msg.name }} final: public ::EmbeddedProto::MessageInterface
               ::EmbeddedProto::ReadBufferSection bufferSection(buffer, size);
               result = result && {{field.variable_name}}.deserialize(bufferSection);
               {% else %}
-              result = ::EmbeddedProto::WireFormatter::{{field.deserialization_func}}(buffer, {{field.variable_name}});
+              result = ::EmbeddedProto::{{field.deserialization_func}}(buffer, {{field.variable_name}});
               {% endif %}
             }
             else

generator/protoc-gen-eams.py

@@ -52,7 +52,7 @@ class FieldTemplateParameters:
                         FieldDescriptorProto.TYPE_INT32:    "EmbeddedProto::int32",
                         FieldDescriptorProto.TYPE_FIXED64:  "EmbeddedProto::fixed64",
                         FieldDescriptorProto.TYPE_FIXED32:  "EmbeddedProto::fixed32",
-                        FieldDescriptorProto.TYPE_BOOL:     "bool",
+                        FieldDescriptorProto.TYPE_BOOL:     "EmbeddedProto::boolean",
                         FieldDescriptorProto.TYPE_STRING:   "TODO",     # TODO
                         FieldDescriptorProto.TYPE_BYTES:    "TODO",     # TODO
                         FieldDescriptorProto.TYPE_UINT32:   "EmbeddedProto::uint32",
@@ -79,39 +79,39 @@ class FieldTemplateParameters:
                          FieldDescriptorProto.TYPE_FLOAT:    "FIXED32",
                          FieldDescriptorProto.TYPE_SFIXED32: "FIXED32"}
 
-    type_to_ser_func = {FieldDescriptorProto.TYPE_DOUBLE:   "SerializeDouble",
-                        FieldDescriptorProto.TYPE_FLOAT:    "SerializeFloat",
-                        FieldDescriptorProto.TYPE_INT64:    "SerializeInt",
-                        FieldDescriptorProto.TYPE_UINT64:   "SerializeUInt",
-                        FieldDescriptorProto.TYPE_INT32:    "SerializeInt",
-                        FieldDescriptorProto.TYPE_FIXED64:  "SerializeFixed",
-                        FieldDescriptorProto.TYPE_FIXED32:  "SerializeFixed",
-                        FieldDescriptorProto.TYPE_BOOL:     "SerializeBool",
-                        FieldDescriptorProto.TYPE_ENUM:     "SerializeEnum",
+    type_to_ser_func = {FieldDescriptorProto.TYPE_DOUBLE:   "serialize",
+                        FieldDescriptorProto.TYPE_FLOAT:    "serialize",
+                        FieldDescriptorProto.TYPE_INT64:    "serialize",
+                        FieldDescriptorProto.TYPE_UINT64:   "serialize",
+                        FieldDescriptorProto.TYPE_INT32:    "serialize",
+                        FieldDescriptorProto.TYPE_FIXED64:  "serialize",
+                        FieldDescriptorProto.TYPE_FIXED32:  "serialize",
+                        FieldDescriptorProto.TYPE_BOOL:     "serialize",
+                        FieldDescriptorProto.TYPE_ENUM:     "serialize",
                         FieldDescriptorProto.TYPE_STRING:   "TODO",     # TODO
                         FieldDescriptorProto.TYPE_BYTES:    "TODO",     # TODO
-                        FieldDescriptorProto.TYPE_UINT32:   "SerializeUInt",
-                        FieldDescriptorProto.TYPE_SFIXED32: "SerializeSFixed",
-                        FieldDescriptorProto.TYPE_SFIXED64: "SerializeSFixed",
-                        FieldDescriptorProto.TYPE_SINT32:   "SerializeSInt",
-                        FieldDescriptorProto.TYPE_SINT64:   "SerializeSInt"}
-
-    type_to_deser_func = {FieldDescriptorProto.TYPE_DOUBLE:   "DeserializeDouble",
-                          FieldDescriptorProto.TYPE_FLOAT:    "DeserializeFloat",
-                          FieldDescriptorProto.TYPE_INT64:    "DeserializeInt",
-                          FieldDescriptorProto.TYPE_UINT64:   "DeserializeUInt",
-                          FieldDescriptorProto.TYPE_INT32:    "DeserializeInt",
-                          FieldDescriptorProto.TYPE_FIXED64:  "DeserializeFixed",
-                          FieldDescriptorProto.TYPE_FIXED32:  "DeserializeFixed",
-                          FieldDescriptorProto.TYPE_BOOL:     "DeserializeBool",
-                          FieldDescriptorProto.TYPE_ENUM:     "DeserializeEnum",
+                        FieldDescriptorProto.TYPE_UINT32:   "serialize",
+                        FieldDescriptorProto.TYPE_SFIXED32: "serialize",
+                        FieldDescriptorProto.TYPE_SFIXED64: "serialize",
+                        FieldDescriptorProto.TYPE_SINT32:   "serialize",
+                        FieldDescriptorProto.TYPE_SINT64:   "serialize"}
+
+    type_to_deser_func = {FieldDescriptorProto.TYPE_DOUBLE:   "deserialize",
+                          FieldDescriptorProto.TYPE_FLOAT:    "deserialize",
+                          FieldDescriptorProto.TYPE_INT64:    "deserialize",
+                          FieldDescriptorProto.TYPE_UINT64:   "deserialize",
+                          FieldDescriptorProto.TYPE_INT32:    "deserialize",
+                          FieldDescriptorProto.TYPE_FIXED64:  "deserialize",
+                          FieldDescriptorProto.TYPE_FIXED32:  "deserialize",
+                          FieldDescriptorProto.TYPE_BOOL:     "deserialize",
+                          FieldDescriptorProto.TYPE_ENUM:     "deserialize",
                           FieldDescriptorProto.TYPE_STRING:   "TODO",     # TODO
                           FieldDescriptorProto.TYPE_BYTES:    "TODO",     # TODO
-                          FieldDescriptorProto.TYPE_UINT32:   "DeserializeUInt",
-                          FieldDescriptorProto.TYPE_SFIXED32: "DeserializeSFixed",
-                          FieldDescriptorProto.TYPE_SFIXED64: "DeserializeSFixed",
-                          FieldDescriptorProto.TYPE_SINT32:   "DeserializeSInt",
-                          FieldDescriptorProto.TYPE_SINT64:   "DeserializeSInt"}
+                          FieldDescriptorProto.TYPE_UINT32:   "deserialize",
+                          FieldDescriptorProto.TYPE_SFIXED32: "deserialize",
+                          FieldDescriptorProto.TYPE_SFIXED64: "deserialize",
+                          FieldDescriptorProto.TYPE_SINT32:   "deserialize",
+                          FieldDescriptorProto.TYPE_SINT64:   "deserialize"}
 
     def __init__(self, field_proto):
         self.name = field_proto.name

src/Fields.h

@@ -12,7 +12,7 @@ namespace EmbeddedProto
   class Field 
   {
     public:
-      Field();
+      Field() = default;
       virtual ~Field() = default;
   };
 
@@ -20,7 +20,11 @@ namespace EmbeddedProto
   class FieldTemplate : public Field
   {
     public:
+      typedef TYPE FIELD_TYPE;
+
       FieldTemplate() = default;
+      FieldTemplate(const TYPE& v) : value_(v) { };
+      FieldTemplate(const TYPE&& v) : value_(v) { };
       ~FieldTemplate() override = default;
 
       void set(const TYPE& v) { value_ = v; }      
@@ -28,7 +32,7 @@ namespace EmbeddedProto
       void operator=(const TYPE& v) { value_ = v; }
       void operator=(const TYPE&& v) { value_ = v; }
 
-      TYPE& get() const { return value_; }
+      const TYPE& get() const { return value_; }
       TYPE& get() { return value_; }
 
     private:
@@ -39,8 +43,8 @@ namespace EmbeddedProto
   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 sint32 : public FieldTemplate<int32_t> { };    
+  class sint64 : public FieldTemplate<int64_t> { };    
   class boolean : public FieldTemplate<bool> { };
   // TODO enum
   class fixed32 : public FieldTemplate<uint32_t> { };   
@@ -50,84 +54,84 @@ namespace EmbeddedProto
   class floatfixed : public FieldTemplate<float> { };   
   class doublefixed : public FieldTemplate<double> { }; 
 
-  bool serialize(uint32_t field_number, int32& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const int32& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeInt(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, int64& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const int64& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeInt(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, uint32& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const uint32& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeUInt(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, uint64& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const uint64& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeUInt(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, sint32& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const sint32& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeSInt(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, sint64& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const 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, const boolean x, WriteBufferInterface& buffer) 
+  { return WireFormatter::SerializeBool(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, fixed32& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const fixed32& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeFixed(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, fixed64& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const fixed64& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeFixed(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, sfixed32& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const sfixed32& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeSFixed(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, sfixed64& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const sfixed64& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeSFixed(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, floatfixed& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const floatfixed& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeFloat(field_number, x.get(), buffer); }
 
-  bool serialize(uint32_t field_number, doublefixed& x, WriteBufferInterface& buffer) 
+  bool serialize(uint32_t field_number, const doublefixed& x, WriteBufferInterface& buffer) 
   { return WireFormatter::SerializeDouble(field_number, x.get(), buffer); }
 
 
 
-  bool deserialize(int32& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, int32& x) 
   { return WireFormatter::DeserializeInt(buffer, x.get()); }
 
-  bool deserialize(int64& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, int64& x) 
   { return WireFormatter::DeserializeInt(buffer, x.get()); }
 
-  bool deserialize(uint32& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, uint32& x) 
   { return WireFormatter::DeserializeUInt(buffer, x.get()); }
 
-  bool deserialize(uint64& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, uint64& x) 
   { return WireFormatter::DeserializeUInt(buffer, x.get()); }
 
-  bool deserialize(sint32& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, sint32& x) 
   { return WireFormatter::DeserializeSInt(buffer, x.get()); }
 
-  bool deserialize(sint64& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, sint64& x) 
   { return WireFormatter::DeserializeSInt(buffer, x.get()); }
 
-  bool deserialize(bool x, ReadBufferInterface& buffer) 
-  { return WireFormatter::DeserializeBool(buffer, x); }
+  bool deserialize(ReadBufferInterface& buffer, boolean& x) 
+  { return WireFormatter::DeserializeBool(buffer, x.get()); }
 
-  bool deserialize(fixed32& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, fixed32& x) 
   { return WireFormatter::DeserializeFixed(buffer, x.get()); }
 
-  bool deserialize(fixed64& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, fixed64& x) 
   { return WireFormatter::DeserializeFixed(buffer, x.get()); }
 
-  bool deserialize(sfixed32& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, sfixed32& x) 
   { return WireFormatter::DeserializeSFixed(buffer, x.get()); }
 
-  bool deserialize(sfixed64& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, sfixed64& x) 
   { return WireFormatter::DeserializeSFixed(buffer, x.get()); }
 
-  bool deserialize(floatfixed& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, floatfixed& x) 
   { return WireFormatter::DeserializeFloat(buffer, x.get()); }
 
-  bool deserialize(doublefixed& x, ReadBufferInterface& buffer) 
+  bool deserialize(ReadBufferInterface& buffer, doublefixed& x) 
   { return WireFormatter::DeserializeDouble(buffer, x.get()); }
 
 } // End of namespace EmbeddedProto.