Add simple vector implementation to kutil for device_manager

src/modules/kutil/memory.cpp

@@ -6,8 +6,17 @@ void *
 memset(void *s, uint8_t v, size_t n)
 {
 	uint8_t *p = reinterpret_cast<uint8_t *>(s);
-	for (int i = 0; i < n; ++i) p[i] = 0;
+	for (size_t i = 0; i < n; ++i) p[i] = v;
 	return s;
 }
 
+void *
+memcpy(void *dest, void *src, size_t n)
+{
+	uint8_t *s = reinterpret_cast<uint8_t *>(src);
+	uint8_t *d = reinterpret_cast<uint8_t *>(dest);
+	for (size_t i = 0; i < n; ++i) d[i] = s[i];
+	return d;
+}
+
 } // namespace kutil

src/modules/kutil/memory.h

@@ -8,8 +8,20 @@ using addr_t = uint64_t;
 
 namespace kutil {
 
+/// Fill memory with the given value.
+/// \arg p   The beginning of the memory area to fill
+/// \arg v   The byte value to fill memory with
+/// \arg n   The size in bytes of the memory area
+/// \returns A pointer to the filled memory
 void * memset(void *p, uint8_t v, size_t n);
 
+/// Copy an area of memory to another
+/// \dest    The memory to copy to
+/// \src     The memory to copy from
+/// \n       The number of bytes to copy
+/// \returns A pointer to the destination memory
+void * memcpy(void *dest, void *src, size_t n);
+
 template <typename T>
 inline T read_from(const void *p) { return *reinterpret_cast<const T *>(p); }
 

src/modules/kutil/vector.h

@@ -0,0 +1,132 @@
+#pragma once
+/// \file vector.h
+/// Definition of a simple dynamic vector collection for use in kernel space
+
+#include <algorithm>
+#include "kutil/memory.h"
+
+namespace kutil {
+
+/// A dynamic array.
+template <typename T>
+class vector
+{
+public:
+	/// Default constructor. Creates an empty vector with no capacity.
+	vector() :
+		m_size(0),
+		m_capacity(0),
+		m_elements(nullptr)
+	{}
+
+	/// Constructor. Creates an empty array with capacity.
+	/// \arg capacity  Initial capacity to allocate
+	vector(size_t capacity) :
+		m_size(0),
+		m_capacity(0),
+		m_elements(nullptr)
+	{
+		set_capacity(capacity);
+	}
+
+	/// Copy constructor. Allocates a copy of the other's array.
+	vector(const vector& other) :
+		m_size(0),
+		m_capacity(0),
+		m_elements(nullptr)
+	{
+		set_capacity(other.m_capacity);
+		kutil::memcpy(m_elements, other.m_elements, other.m_size * sizeof(T));
+		m_size = other.m_size;
+	}
+
+	/// Move constructor. Takes ownership of the other's array.
+	vector(vector&& other) :
+		m_size(other.m_size),
+		m_capacity(other.m_capacity),
+		m_elements(other.m_elements)
+	{
+		other.m_size = 0;
+		other.m_capacity = 0;
+		other.m_elements = nullptr;
+	}
+
+	/// Destructor. Destroys any remaining items in the array.
+	~vector()
+	{
+		while (m_size) remove();
+		delete [] m_elements;
+	}
+
+	/// Access an element in the array.
+	inline T & operator[] (size_t i) { return m_elements[i]; }
+
+	/// Access an element in the array.
+	inline const T & operator[] (size_t i) const { return m_elements[i]; }
+
+	/// Add an item onto the array by copying it.
+	/// \arg item the item to add
+	void append(const T& item)
+	{
+		ensure_capacity(m_size + 1);
+		m_elements[m_size] = item;
+		m_size += 1;
+	}
+
+	/// Remove an item from the end of the array.
+	void remove()
+	{
+		m_size -= 1;
+		m_elements[m_size].~T();
+	}
+
+	/// Set the size of the array. Any new items are default
+	/// constructed. The array is realloced if needed.
+	/// \arg size  The new size
+	void set_size(size_t size)
+	{
+		ensure_capacity(size);
+		for (size_t i = m_size; i < size; ++i)
+			new (&m_elements[i]) T;
+		m_size = size;
+	}
+
+	/// Ensure the array will fit an item.
+	/// \arg size  Size of the array
+	void ensure_capacity(size_t size)
+	{
+		if (m_capacity >= size) return;
+
+		size_t capacity = m_capacity;
+		while (capacity < size) {
+			if (capacity == 0) capacity = 4;
+			else capacity *= 2;
+		}
+		set_capacity(capacity);
+	}
+
+	/// Reallocate the array. Copy over any old elements that will
+	/// fit into the new array. The rest are destroyed.
+	/// \arg capacity  Number of elements to allocate
+	void set_capacity(size_t capacity)
+	{
+		T *new_array = new T[capacity];
+		size_t size = std::min(capacity, m_size);
+
+		kutil::memcpy(new_array, m_elements, size * sizeof(T));
+
+		while (size < m_size) remove();
+		m_size = size;
+		m_capacity = capacity;
+
+		delete [] m_elements;
+		m_elements = new_array;
+	}
+
+private:
+	size_t m_size;
+	size_t m_capacity;
+	T *m_elements;
+};
+
+} // namespace kutil