Exchanged Span for Array.

Author: jfjlaros

src/array.tcc

@@ -0,0 +1,90 @@
+#pragma once
+
+template <class T, size_t n>
+class Array {
+public:
+  Array() = default;
+
+  /*!
+   * Create an array using an initialiser list.
+   *
+   * \param data... Data.
+   */
+  template <class... Ts>
+    Array(Ts...);
+
+  /*!
+   * Create an Array using a C array.
+   *
+   * \param arr C array.
+   */
+  Array(T const (&)[n]);
+
+  T& operator[](size_t const);
+  T const& operator[](size_t const) const;
+
+  T* begin();
+  T* end();
+  T const* begin() const;
+  T const* end() const;
+
+  /*!
+   * Get the number of elements.
+   *
+   * \return Array size.
+   */
+  size_t size() const;
+
+private:
+  T arr_[n] {};
+};
+
+
+template <class T, size_t n>
+template <class... Ts>
+Array<T, n>::Array(Ts... data) : arr_ {data...} {}
+
+template <class T, size_t n>
+Array<T, n>::Array(T const (&arr)[n]) {
+  for (size_t i {0}; i < n; ++i) {
+    arr_[i] = arr[i];
+  }
+}
+
+
+template <class T, size_t n>
+T& Array<T, n>::operator[](size_t const idx) {
+  return arr_[idx];
+}
+
+template <class T, size_t n>
+T const& Array<T, n>::operator[](size_t const idx) const {
+  return arr_[idx];
+}
+
+
+template <class T, size_t n>
+T* Array<T, n>::begin() {
+  return arr_;
+}
+
+template <class T, size_t n>
+T* Array<T, n>::end() {
+  return arr_ + n;
+}
+
+template <class T, size_t n>
+T const * Array<T, n>::begin() const {
+  return arr_;
+}
+
+template <class T, size_t n>
+T const* Array<T, n>::end() const {
+  return arr_ + n;
+}
+
+
+template <class T, size_t n>
+size_t Array<T, n>::size() const {
+  return n;
+}

src/read.tcc

@@ -3,6 +3,7 @@
 #include "defs.h"
 #include "tuple.tcc"
 #include "vector.tcc"
+#include "array.tcc"
 
 //! \defgroup read
 
@@ -67,10 +68,9 @@ inline void rpcRead(Stream& io, String* data) {
 template <class T>
 void rpcRead(Stream& io, Vector<T>* data) {
   size_t size;
-
   rpcRead(io, &size);
-  (*data).resize(size);
 
+  (*data).resize(size);
   for (size_t i {0}; i < (*data).size(); i++) {
     rpcRead(io, &(*data)[i]);
   }
@@ -81,15 +81,26 @@ void rpcRead(Stream& io, Vector<T>* data) {
 template <class T>
 void rpcRead(Stream& io, T** data) {
   size_t size;
-
   rpcRead(io, &size);
-  *data = new T[size];
 
+  *data = new T[size];
   for (size_t i {0}; i < size; i++) {
     rpcRead(io, *data + i);
   }
 }
 
+/*! \ingroup read
+ * \copydoc rpcRead(Stream&, T*) */
+template <class T, size_t n>
+void rpcRead(Stream& io, Array<T, n>* data) {
+  size_t size;
+  rpcRead(io, &size);
+
+  for (size_t i {0}; i < min(size, n); i++) {
+    rpcRead(io, &(*data)[i]);
+  }
+}
+
 /*! \ingroup read
  * \copydoc rpcRead(Stream&, T*) */
 template <class T>

src/span.tcc

@@ -3,6 +3,7 @@
 #include "print.tcc"
 #include "tuple.tcc"
 #include "vector.tcc"
+#include "array.tcc"
 
 //! \defgroup types
 
@@ -165,9 +166,20 @@ void rpcTypeOf(Stream& io, Object<Membs...>& o) {
  * \copydoc rpcTypeOf(Stream&, bool) */
 template <class T>
 void rpcTypeOf(Stream& io, Vector<T>&) {
+  rpcPrint(io, '[');
   T x {};
+  rpcTypeOf(io, x);
+  rpcPrint(io, ']');
+}
 
+/*! \ingroup types
+ * \copydoc rpcTypeOf(Stream&, bool) */
+template <class T, size_t n>
+void rpcTypeOf(Stream& io, Array<T, n>&) {
   rpcPrint(io, '[');
+  size_t n_ {n};
+  rpcPrint(io, n_);
+  T x {};
   rpcTypeOf(io, x);
   rpcPrint(io, ']');
 }
@@ -176,13 +188,14 @@ void rpcTypeOf(Stream& io, Vector<T>&) {
  * \copydoc rpcTypeOf(Stream&, bool) */
 template <class T>
 void rpcTypeOf(Stream& io, T*) {
-  T x {};
-
   rpcPrint(io, '[');
+  T x {};
   rpcTypeOf(io, x);
   rpcPrint(io, ']');
 }
 
+// TODO: References to arrays can be returned, e.g., int (&test())[10] {}
+
 
 /*! \ingroup types
  * Determine endianness and type of `size_t`.

src/types.tcc

@@ -29,15 +29,15 @@ public:
   /*!
    * Create a Vector with `size` elements from a C array.
    *
-   * \param data C array.
+   * \param arr C array.
    */
   template <size_t n>
     Vector(T const (&)[n]);
 
   /*!
    * Create a Vector with `size` elements from a block of raw memory.
    *
-   * \param data Pointer to data, Vector takes ownership.
+   * \param ptr Pointer to data, Vector takes ownership.
    * \param size Vector size.
    */
   Vector(T* const, size_t const);
@@ -113,14 +113,14 @@ Vector<T>::Vector(size_t const size)
     : size_ {size}, data_ {new T[size]} {}
 
 template <class T>
-Vector<T>::Vector(T* const data, size_t const size)
-    : size_ {size}, data_ {data} {}
+Vector<T>::Vector(T* const ptr, size_t const size)
+    : size_ {size}, data_ {ptr} {}
 
 template <class T>
 template <size_t n>
-Vector<T>::Vector(T const (&data)[n])
+Vector<T>::Vector(T const (&arr)[n])
     : size_ {n}, data_ {new T[n]} {
-  copy_(data);
+  copy_(arr);
 }
 
 template <class T>

src/vector.tcc

@@ -3,12 +3,13 @@
 #include "print.tcc"
 #include "tuple.tcc"
 #include "vector.tcc"
+#include "array.tcc"
 
 //! \defgroup write
 
 
 /*! \ingroup write
- * Write a value to an stream.
+ * Write a value to a stream.
  *
  * \param io Stream.
  * \param data Data.
@@ -49,6 +50,17 @@ void rpcWrite(Stream& io, Vector<T>* data) {
   }
 }
 
+/*! \ingroup write
+ * \copydoc rpcWrite(Stream&, T*) */
+template <class T, size_t n>
+void rpcWrite(Stream& io, Array<T, n>* data) {
+  size_t size {(*data).size()};
+  rpcWrite(io, &size);
+  for (size_t i {0}; i < size; i++) {
+    rpcWrite(io, &(*data)[i]);
+  }
+}
+
 
 //! Recursion terminator for `rpcWrite(Tuple*)()`.
 inline void rpcWrite(Stream&, Tuple<>*) {}