Added section headings

Author: NathanJPhillips

src/util/serializer.h

@@ -56,6 +56,9 @@ Class: serializert
 \*******************************************************************/
 class serializert
 {
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Data used in this class
+
 private:
   // The serializer for a containing object, if any
   serializert *parent;
@@ -64,6 +67,9 @@ class serializert
   // Traits attached to this serializer
   serializer_traitst *traits;
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Constructors/destructors
+
 protected:
   /*******************************************************************\
 
@@ -108,6 +114,9 @@ class serializert
   // The virtual destructor ensures sub-classes are disposed correctly.
   virtual ~serializert()=default;
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Accessors
+
 public:
   /*******************************************************************\
 
@@ -185,6 +194,9 @@ class serializert
     traits=&serializer_traits;
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serialization of basic data types
+
 public:
   /*******************************************************************\
 
@@ -298,7 +310,9 @@ class serializert
   \*******************************************************************/
   virtual void serialize(const char *name, float &field)=0;
 
-  // Serializing objects that implement a serialize method
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing objects that implement a serialize method
+
 protected:
   // This is a non-templated function so that it can be virtual
   // It therefore can't take an object of the type to be serialized
@@ -339,29 +353,28 @@ class serializert
 
   /*******************************************************************\
 
-  Function: serializert::serialize
+  Function: serializert::read_object
 
   Template parameters:
     T:
-      The type of the field to serialize. Must be serializable.
+      The type of the field to read.
+      Must implement a serialize method and have a default constructor.
 
   Inputs:
-    name: The name of the field to serialize.
-    field: An rvalue reference to the field to serialize.
 
   Outputs:
+    An object of the type T read from the serializer.
 
   Purpose:
     Serializes a field.
-    Since the field is an rvalue reference this override is useful for writing
-      temporary objects or reading into temporary objects that store their
-      values in a non-temporary.
 
   \*******************************************************************/
   template<typename T>
-  void serialize(const char *name, T &&field)
+  T read_object()
   {
-    serialize(name, static_cast<T &>(field));
+    T result;
+    result.serialize(*this);
+    return result;
   }
 
   /*******************************************************************\
@@ -371,53 +384,60 @@ class serializert
   Template parameters:
     T:
       The type of the field to read.
-      Must implement a serialize method and have a default constructor.
+      Must be serializable and have a default constructor.
 
   Inputs:
+    name: The name of the field to serialize.
 
   Outputs:
-    An object of the type T read from the serializer.
+    An object of the type T read from the field serializer.
 
   Purpose:
     Serializes a field.
 
   \*******************************************************************/
   template<typename T>
-  T read_object()
+  T read_object(const char *name)
   {
     T result;
-    result.serialize(*this);
+    serialize(name, result);
     return result;
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing rvalue references
+
+public:
   /*******************************************************************\
 
-  Function: serializert::read_object
+  Function: serializert::serialize
 
   Template parameters:
     T:
-      The type of the field to read.
-      Must be serializable and have a default constructor.
+      The type of the field to serialize. Must be serializable.
 
   Inputs:
     name: The name of the field to serialize.
+    field: An rvalue reference to the field to serialize.
 
   Outputs:
-    An object of the type T read from the field serializer.
 
   Purpose:
     Serializes a field.
+    Since the field is an rvalue reference this override is useful for writing
+      temporary objects or reading into temporary objects that store their
+      values in a non-temporary.
 
   \*******************************************************************/
   template<typename T>
-  T read_object(const char *name)
+  void serialize(const char *name, T &&field)
   {
-    T result;
-    serialize(name, result);
-    return result;
+    serialize(name, static_cast<T &>(field));
   }
 
-  // Serializing pairs of serializable values
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing pairs of serializable values
+
 private:
   /*******************************************************************\
 
@@ -490,21 +510,30 @@ class serializert
     serialize(name, serializable_pairt<std::pair<firstt, secondt>>(field));
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing vectors
+
 public:
-  // A helper class for writing vectors
+  // A helper base class for writing vectors
   class collection_writert
   {
   public:
     virtual bool is_end() const=0;
     virtual void write(serializert &serializer)=0;
   };
 
+  // Virtual function that must be implemented to support reading vectors
   virtual void read_array(
     const char *name,
     std::function<void(serializert &serializer)> read_elt)=0;
+
+  // Virtual function that must be implemented to support writing vectors
   virtual void write_array(
     const char *name, collection_writert &collection_writer)=0;
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing vectors of objects that implement a serialize method
+
 public:
   // A helper class for writing vectors of objects that implement a serialize
   //  method
@@ -581,6 +610,9 @@ class serializert
     }
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing vectors of serializable values
+
 protected:
   // A helper class for writing vectors of serializable objects (wrapped in a
   //  value field)
@@ -655,6 +687,9 @@ class serializert
     }
   }
 
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing sets of serializable values
+
 public:
   /*******************************************************************\
 
@@ -754,7 +789,9 @@ class serializert
     serialize_set(name, field);
   }
 
-  // Serializing maps of serializable values
+  /////////////////////////////////////////////////////////////////////////////
+  // Section: Serializing maps of serializable values
+
 private:
   // This helper function can serialize any type of map (mapt) that has member
   //  types key_type, mapped_type, value_type and reference, an insert method