slight changes ,size t replacement

container/ArrayList.h

@@ -1,15 +1,15 @@
-#ifndef ARRAYLIST_H_
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
-#define ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
 
 /**
- * A List that stores its values in an array.
+ * @brief 	A List that stores its values in an array.
- *
+ * @details
- * The backend is an array that can be allocated by the class itself or supplied via ctor.
+ * The underlying storage is an array that can be allocated by the class
- *
+ * itself or supplied via ctor.
  *
  * @ingroup container
  */
@@ -20,6 +20,53 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
+	/**
+	 * This is the allocating constructor.
+	 * It allocates an array of the specified size.
+	 * @param maxSize
+	 */
+	ArrayList(count_t maxSize) :
+			size(0), maxSize_(maxSize), allocated(true) {
+		entries = new T[maxSize];
+	}
+
+	/**
+	 * This is the non-allocating constructor
+	 *
+	 * It expects a pointer to an array of a certain size and initializes
+	 * itself to it.
+	 *
+	 * @param storage the array to use as backend
+	 * @param maxSize size of storage
+	 * @param size size of data already present in storage
+	 */
+	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+	}
+
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+	ArrayList(const ArrayList& other) = delete;
+	const ArrayList& operator=(const ArrayList& other) = delete;
+
+	/**
+	 * Number of Elements stored in this List
+	 */
+	count_t size;
+
+
+	/**
+	 * Destructor, if the allocating constructor was used, it deletes the array.
+	 */
+	virtual ~ArrayList() {
+		if (allocated) {
+			delete[] entries;
+		}
+	}
+
     /**
      * An Iterator to go trough an ArrayList
      *
@@ -31,10 +78,7 @@ public:
         /**
          * Empty ctor, points to NULL
          */
-		Iterator() :
+        Iterator(): value(0) {}
-				value(0) {
-
-		}
 
         /**
          * Initializes the Iterator to point to an element
@@ -72,72 +116,36 @@ public:
             return tmp;
         }
 
-		T& operator*(){
+        T& operator*() {
             return *value;
         }
 
-		const T& operator*() const{
+        const T& operator*() const {
             return *value;
         }
 
-		T *operator->(){
+        T *operator->() {
             return value;
         }
 
-		const T *operator->() const{
+        const T *operator->() const {
             return value;
         }
 
+
         //SHOULDDO this should be implemented as non-member
-		bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
+        bool operator==(const typename
+        		ArrayList<T, count_t>::Iterator& other) const {
             return (value == other.value);
         }
 
         //SHOULDDO this should be implemented as non-member
-		bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
+        bool operator!=(const typename
+        		ArrayList<T, count_t>::Iterator& other) const {
         	return !(*this == other);
         }
     };
 
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
-
-	/**
-	 * This is the allocating constructor;
-	 *
-	 * It allocates an array of the specified size.
-	 *
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
-
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
-
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
-
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -191,7 +199,7 @@ public:
 	 *
 	 * @return maximum number of elements
 	 */
-	uint32_t maxSize() const {
+	size_t maxSize() const {
 		return this->maxSize_;
 	}
 
@@ -226,19 +234,7 @@ public:
 	count_t remaining() {
 		return (maxSize_ - size);
 	}
-private:
+
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_), allocated(
-					false) {
-	}
 protected:
 	/**
 	 * pointer to the array in which the entries are stored
@@ -247,12 +243,12 @@ protected:
 	/**
 	 * remembering the maximum size
 	 */
-	uint32_t maxSize_;
+	size_t maxSize_;
 
 	/**
 	 * true if the array was allocated and needs to be deleted in the destructor.
 	 */
 	bool allocated;
-
 };
-#endif /* ARRAYLIST_H_ */
+
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */