Added Span for easy C array handling.

Author: jfjlaros

src/span.tcc

@@ -0,0 +1,85 @@
+template <class T>
+class Span {
+public:
+  Span() = default;
+
+  /*!
+   * Create a Span with `n` elements.
+   */
+  template <size_t n>
+    Span(T (&)[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 underlying data.
+   *
+   * \return data.
+   */
+  T* data() const;
+
+  /*!
+   * Get the number of elements.
+   *
+   * \return Span size.
+   */
+  size_t size() const;
+
+private:
+  T* data_ {};
+  size_t size_ {};
+};
+
+
+template <class T>
+template <size_t n>
+Span<T>::Span(T (&a)[n]) : data_ {a}, size_ {n} {}
+
+
+template <class T>
+T& Span<T>::operator [](size_t const idx) {
+  return data_[idx];
+}
+
+template <class T>
+T const& Span<T>::operator [](size_t const idx) const {
+  return data_[idx];
+}
+
+
+template <class T>
+T* Span<T>::begin() {
+  return data_;
+}
+
+template <class T>
+T* Span<T>::end() {
+  return data_ + size_;
+}
+
+template <class T>
+T const* Span<T>::begin() const {
+  return data_;
+}
+
+template <class T>
+T const* Span<T>::end() const {
+  return data_ + size_;
+}
+
+
+template <class T>
+T* Span<T>::data() const {
+  return data_;
+}
+
+template <class T>
+size_t Span<T>::size() const {
+  return size_;
+}

tests/test_span.cc

@@ -0,0 +1,90 @@
+#include <catch.hpp>
+
+#include "../src/span.tcc"
+
+
+TEST_CASE("Span initialisation.", "[span]") {
+  int data[] {1, 2, 3};
+  Span<int> s {data};
+
+  REQUIRE(s.size() == 3);
+  REQUIRE(s[1] == 2);
+}
+
+TEST_CASE("Span set and get elements.", "[span]") {
+  int data[2] {};
+  Span<int> s {data};
+
+  data[0] = 1234;
+  data[1] = 2345;
+
+  REQUIRE(s.size() == 2);
+  REQUIRE(s[0] == 1234);
+  REQUIRE(s[1] == 2345);
+}
+
+TEST_CASE("Span get constant elements.", "[span]") {
+  int const data[] {1234, 2345};
+  Span<int const> const s {data};
+
+  REQUIRE(s.size() == 2);
+  REQUIRE(s[0] == 1234);
+  REQUIRE(s[1] == 2345);
+}
+
+
+TEST_CASE("Span range loop.", "[span]") {
+  int data[2] {};
+  Span<int> s {data};
+
+  for (int& el: s) {
+    el = 1234;
+  }
+  for (int const& el: s) {
+    REQUIRE(el == 1234);
+  }
+}
+
+
+TEST_CASE("Span data.", "[span]") {
+  int data[2] {};
+  Span<int> s {data};
+
+  REQUIRE(s.data() == data);
+}
+
+TEST_CASE("Span size.", "[span]") {
+  int data[2] {};
+  Span<int> s {data};
+
+  REQUIRE(s.size() == 2);
+}
+
+
+TEST_CASE("Span return.", "[span]") {
+  struct S {
+    static Span<int> f() {
+      static int data[] {1234, 2345};
+      Span<int> s {data};
+      return s;
+    }
+  };
+
+  Span<int> s {};
+  s = S::f();
+
+  REQUIRE(s[0] == 1234);
+}
+
+TEST_CASE("Span pass by value.", "[span]") {
+  struct S {
+    static void f(Span<int> s) {
+      REQUIRE(s.size() == 2);
+      REQUIRE(s[0] == 1234);
+    }
+  };
+
+  int data[] {1234, 2345};
+  Span<int> s {data};
+  S::f(s);
+}