Serializable type for Enums

Autocoders/Python/schema/default/enum_schema.rng

@@ -37,6 +37,14 @@
 
             </optional>
 
+            <optional>
+                <attribute name = "serialize_type">
+                    <a:documentation>Serialization type of the enum.</a:documentation>
+                    <text/>
+                </attribute>
+
+            </optional>
+
             <!-- Elements -->
             <interleave>
                 <optional>

Autocoders/Python/src/fprime_ac/generators/templates/enums/enum_cpp.tmpl

@@ -152,14 +152,22 @@ a == $item_value#slurp
   Fw::SerializeStatus ${name} :: serialize(Fw::SerializeBufferBase& buffer) const
   {
     Fw::SerializeStatus status;
+#if $serialize_type
+    status = buffer.serialize(static_cast<${serialize_type}>(this->e));
+#else
     status = buffer.serialize(static_cast<FwEnumStoreType>(this->e));
+#end if
     return status;
   }
 
   Fw::SerializeStatus ${name} :: deserialize(Fw::SerializeBufferBase& buffer)
   {
     Fw::SerializeStatus status;
+#if $serialize_type
+    ${serialize_type} es;
+#else
     FwEnumStoreType es;
+#end if
     status = buffer.deserialize(es);
     if (status == Fw::FW_SERIALIZE_OK)
       this->e = static_cast<t>(es);

Autocoders/Python/src/fprime_ac/generators/templates/enums/enum_hpp.tmpl

@@ -66,7 +66,11 @@ namespace ${namespace} {
     // ----------------------------------------------------------------------
 
     enum {
+#if $serialize_type
+        SERIALIZED_SIZE = sizeof(${serialize_type})
+#else
         SERIALIZED_SIZE = sizeof(FwEnumStoreType)
+#end if
         };
 
     //! Number of items in ${name} enum 

Autocoders/Python/src/fprime_ac/parsers/XmlEnumParser.py

@@ -56,6 +56,7 @@ def __init__(self, xml_file=None):
         self.__name = ""
         self.__namespace = None
         self.__default = None
+        self.__serialize_type = None
 
         self.__xml_filename = xml_file
         self.__items = []
@@ -107,6 +108,11 @@ def __init__(self, xml_file=None):
         else:
             self.__default = None
 
+        if "serialize_type" in enum.attrib:
+            self.__serialize_type = enum.attrib["serialize_type"]
+        else:
+            self.__serialize_type = None
+
         for enum_tag in enum:
             if enum_tag.tag == "item":
                 item = enum_tag.attrib
@@ -207,6 +213,9 @@ def get_namespace(self):
     def get_default(self):
         return self.__default
 
+    def get_serialize_type(self):
+        return self.__serialize_type
+
     def get_items(self):
         return self.__items
 
@@ -221,8 +230,13 @@ def get_comment(self):
     print("Enum XML parse test (%s)" % xmlfile)
     xml_parser = XmlEnumParser(xmlfile)
     print(
-        "Enum name: %s, namespace: %s, default: %s"
-        % (xml_parser.get_name(), xml_parser.get_namespace(), xml_parser.get_default())
+        "Enum name: %s, namespace: %s, default: %s, serialize_type: %s"
+        % (
+            xml_parser.get_name(),
+            xml_parser.get_namespace(),
+            xml_parser.get_default(),
+            xml_parser.get_serialize_type(),
+        )
     )
     print("Items")
     for item in xml_parser.get_items():

Autocoders/Python/src/fprime_ac/utils/EnumGenerator.py

@@ -37,13 +37,16 @@ def open_file(name, type):
     return fp
 
 
-def write_template(fp, c, name, namespace, default, items, max_value, comment):
+def write_template(
+    fp, c, name, namespace, default, serialize_type, items, max_value, comment
+):
     """
     Set up and write out templates here
     """
     c.name = name
     c.namespace = namespace
     c.default = default
+    c.serialize_type = serialize_type
     c.items_list = items
     c.max_value = max_value
     c.comment = comment
@@ -65,6 +68,7 @@ def generate_enum(xml_file):
         name = enum_xml.get_name()
         namespace = enum_xml.get_namespace()
         default = enum_xml.get_default()
+        serialize_type = enum_xml.get_serialize_type()
         items = enum_xml.get_items()
         max_value = enum_xml.get_max_value()
         comment = enum_xml.get_comment()
@@ -73,14 +77,18 @@ def generate_enum(xml_file):
         #
         fp = open_file(name, "hpp")
         c = enum_hpp.enum_hpp()
-        write_template(fp, c, name, namespace, default, items, max_value, comment)
+        write_template(
+            fp, c, name, namespace, default, serialize_type, items, max_value, comment
+        )
         fp.close()
         #
         # Generate the cpp file
         #
         fp = open_file(name, "cpp")
         c = enum_cpp.enum_cpp()
-        write_template(fp, c, name, namespace, default, items, max_value, comment)
+        write_template(
+            fp, c, name, namespace, default, serialize_type, items, max_value, comment
+        )
         fp.close()
         return True
     else:

Autocoders/Python/test/enum_xml/CMakeLists.txt

@@ -8,6 +8,7 @@ set(SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/Component1ComponentAi.xml"
   "${CMAKE_CURRENT_LIST_DIR}/Enum1EnumAi.xml"
   "${CMAKE_CURRENT_LIST_DIR}/Enum2EnumAi.xml"
+  "${CMAKE_CURRENT_LIST_DIR}/Enum3EnumAi.xml"
   "${CMAKE_CURRENT_LIST_DIR}/Port1PortAi.xml"
   "${CMAKE_CURRENT_LIST_DIR}/Serial1SerializableAi.xml"
 )

Autocoders/Python/test/enum_xml/Component1ComponentAi.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component name="Component1" kind="active" namespace="Example">
     <import_enum_type>Autocoders/Python/test/enum_xml/Enum2EnumAi.xml</import_enum_type>
+    <import_enum_type>Autocoders/Python/test/enum_xml/Enum3EnumAi.xml</import_enum_type>
     <import_port_type>Autocoders/Python/test/enum_xml/Port1PortAi.xml</import_port_type>
     <import_serializable_type>Autocoders/Python/test/enum_xml/Serial1SerializableAi.xml</import_serializable_type>
     <import_dictionary>Autocoders/Python/test/enum_xml/Telemetry.xml</import_dictionary>

Autocoders/Python/test/enum_xml/Enum2EnumAi.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<enum namespace = "Example" name="Enum2">
+<enum namespace = "Example" name="Enum2" serialize_type="U64">
     <comment>Test enum_xml example enum</comment>
     <item name="Item1" value="-1952875139"/>
     <item name="Item2" value="2"/>

Autocoders/Python/test/enum_xml/Enum3EnumAi.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<enum namespace = "Example" name="Enum3" serialize_type="U8">
+    <comment>Test enum_xml example enum</comment>
+    <item name="Item1" value="-1952875139"/>
+    <item name="Item2" value="2"/>
+    <item name="Item3" comment="Test Item" value="2000999333"/>
+    <item name="Item4" value="21"/>
+    <item name="Item5" value="-8324876"/>
+</enum>

Autocoders/Python/test/enum_xml/main.cpp

@@ -179,6 +179,7 @@ TEST(EnumXML, OK) {
     Example::Enum1 enum2;
     Example::Enum1 enum3;
     Example::Enum2 enum4;
+    Example::Enum3 enum5;
 
     Example::Serial1 serial1;
 
@@ -189,6 +190,11 @@ TEST(EnumXML, OK) {
     // Check that enum are set to uninitialized value
     ASSERT_EQ(enum4.e, 0);
 
+    // Check that the enum serializable types are set correctly
+    ASSERT_EQ(Example::Enum1::SERIALIZED_SIZE, sizeof(FwEnumStoreType));
+    ASSERT_EQ(Example::Enum2::SERIALIZED_SIZE, sizeof(U64));
+    ASSERT_EQ(Example::Enum3::SERIALIZED_SIZE, sizeof(U8));
+
     enum1 = getEnumFromI32();
     cout << "Created first enum: " << enum1 << endl;
 
@@ -209,16 +215,38 @@ TEST(EnumXML, OK) {
     // Serialize enums
     U8 buffer1[1024];
     U8 buffer2[1024];
+    U8 buffer3[1024];
+    U8 buffer4[1024];
+    U8 buffer5[1024];
     Fw::SerialBuffer enumSerial1 = Fw::SerialBuffer(buffer1, sizeof(buffer1));
     Fw::SerialBuffer enumSerial2 = Fw::SerialBuffer(buffer2, sizeof(buffer2));
+    Fw::SerialBuffer enumSerial3 = Fw::SerialBuffer(buffer3, sizeof(buffer3));
+    Fw::SerialBuffer enumSerial4 = Fw::SerialBuffer(buffer4, sizeof(buffer4));
+    Fw::SerialBuffer enumSerial5 = Fw::SerialBuffer(buffer5, sizeof(buffer5));
     ASSERT_EQ(enumSerial1.serialize(enum1), Fw::FW_SERIALIZE_OK);
     cout << "Serialized enum1" << endl;
 
     ASSERT_EQ(enumSerial2.serialize(enum2), Fw::FW_SERIALIZE_OK);
     cout << "Serialized enum2" << endl;
 
+    ASSERT_EQ(enumSerial3.serialize(enum3), Fw::FW_SERIALIZE_OK);
+    cout << "Serialized enum3" << endl;
+
+    ASSERT_EQ(enumSerial4.serialize(enum4), Fw::FW_SERIALIZE_OK);
+    cout << "Serialized enum4" << endl;
+
+    ASSERT_EQ(enumSerial5.serialize(enum5), Fw::FW_SERIALIZE_OK);
+    cout << "Serialized enum5" << endl;
+
     cout << "Serialized enums" << endl;
 
+    // Check that the serialized types are correctly set
+    ASSERT_EQ(enumSerial1.getBuffLength(), sizeof(FwEnumStoreType));
+    ASSERT_EQ(enumSerial2.getBuffLength(), sizeof(FwEnumStoreType));
+    ASSERT_EQ(enumSerial3.getBuffLength(), sizeof(FwEnumStoreType));
+    ASSERT_EQ(enumSerial4.getBuffLength(), sizeof(U64));
+    ASSERT_EQ(enumSerial5.getBuffLength(), sizeof(U8));
+
     // Deserialize enums
     ASSERT_EQ(enumSerial1.deserialize(enum1Save), Fw::FW_SERIALIZE_OK);
     cout << "Deserialized enum1" << endl;

docs/UsersGuide/dev/xml-specification.md

@@ -121,10 +121,10 @@ types, in port arguments, in telemetry channels, and in event arguments.
 
 As an example, you can create a file `SwitchStateEnumAi.xml` that specifies an
 XML enumeration type `SwitchState`
-with enumerated constants `OFF` and `ON`, like this:
+with enumerated constants `OFF` and `ON` and set to `OFF` by default, like this:
 
 ```xml
-<enum name="SwitchState">
+<enum name="SwitchState" default="OFF">
   <item name="OFF" value="0"/>
   <item name="ON" value="1"/>
 </enum>
@@ -184,9 +184,22 @@ with attributes *enum_attributes* and children *enum_children*.
 of the enumeration type.
 The namespace consists of one or more identifiers separated by `::`.
 
+* An optional attribute `default` giving the default value
+of the enumeration. This value must match the name attribute of 
+one of the item definitions within the enumeration (see below). 
+
+* An optional attribute `serialize_type` giving the numeric type
+of the enumeration when serializing.
+
 If the attribute `namespace` is missing, then the type is
 placed in the global namespace.
 
+If the attribute `default` is missing, then the value of the
+enumeration is set to 0.
+
+If the attribute `serialize_type` is missing, then the serialization type is
+set to FwEnumStoreType.
+
 _Examples:_ Here is an XML enumeration `E` in the global namespace:
 
 `<enum name="E">` ... `</enum>`
@@ -195,6 +208,17 @@ Here is an XML enumeration `E` in the namespace `A::B`:
 
 `<enum name="E" namespace="A::B">` ... `</enum>`
 
+Here is an XML enumeration `E` in the global namespace with default value Item2 
+(Item2 is assumed to be the name attribute of one of the item definitions in the enum):
+
+`<enum name="E" default="Item2">` ... `</enum>`
+
+
+Here is an XML enumeration `E` in the global namespace with serialization type
+U64:
+
+`<enum name="E" serialize_type="U64">` ... `</enum>`
+
 **Enum children:**
 *enum_children* consists of the following, in any order:
 
@@ -826,4 +850,4 @@ in the connections.
 The XML specification for the component requires static declaration of
 component instances that can be referred to by their object name. If
 components are instantiated in other ways such as a heap, the manual
-method can be used.
+method can be used.