added override specifiers, some doc fixes

serialize/SerialLinkedListAdapter.h

@@ -18,23 +18,25 @@
  * 		   	or vice-versa, using linked lists.
  * @details
  * An alternative to the AutoSerializeAdapter functions
- *   - All object members with a datatype are declared as SerializeElement<element_type>
- * 	   members inside the class implementing this adapter.
- *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
- *     with a known size, where the size can also be serialized
- *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
- *     with a size header, which is scanned automatically
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers with a known size
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
  *
  * The sequence of objects is defined in the constructor by using
  * the setStart and setNext functions.
  *
- * - The serialization process is done by instantiating the class and
- *   calling serializ after all SerializeElement entries have been set by
- *   using the constructor or setter functions. An additional size variable can be supplied
- *   which is calculated/incremented automatically
- * - The deserialization process is done by instantiating the class and supplying
- *   a buffer with the data which is converted into an object. The size of
- *   data to serialize can be supplied and is decremented in the function
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
  *
  * @ingroup serialize
  */
@@ -55,10 +57,12 @@ public:
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
 	}
+
 	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
 			SinglyLinkedList<T>(first), printCount(printCount) {
 
 	}
+
 	SerialLinkedListAdapter(bool printCount = false) :
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
@@ -66,15 +70,16 @@ public:
 	/**
 	 * Serialize object implementing this adapter into the supplied buffer
 	 * and calculate the serialized size
-	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
-	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param buffer [out] Object is serialized into this buffer.
+	 *    Note that the buffer pointer *buffer is incremented automatically
+	 *    inside the respective serialize functions
 	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
 	 * @param max_size
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const override{
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -98,7 +103,9 @@ public:
 		}
 		return result;
 	}
-	virtual size_t getSerializedSize() const {
+
+
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -106,6 +113,7 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
+
 	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
 		uint32_t size = 0;
 		while (element != NULL) {
@@ -115,15 +123,17 @@ public:
 		return size;
 	}
 
+
 	/**
-	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * Deserialize supplied buffer with supplied size into object
+	 * implementing this adapter.
 	 * @param buffer
 	 * @param size Decremented in respective deSerialize functions automatically
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
@@ -138,7 +148,6 @@ public:
 	}
 
 	bool printCount;
-
 };
 
 #endif /* SERIALLINKEDLISTADAPTER_H_ */