Improved Tuple, removed Object.

Author: jfjlaros

docs/api/tuple.rst

@@ -1,5 +1,5 @@
-Tuples and Objects
-==================
+Tuples
+======
 
 .. code-block:: cpp
 
@@ -19,7 +19,7 @@ Initialisation of a Tuple can be done with a brace-initializer-list as follows.
 
 .. code-block:: cpp
 
-    Tuple<int, char> t = {10, 'c'};
+    Tuple<int, char> t {10, 'c'};
 
 Element retrieval and assignment is described below in the :ref:`Helper
 functions` section.
@@ -34,39 +34,11 @@ Class definitions
    :content-only:
 
 
-Objects
--------
-
-An Object is functionally equivalent to a Tuple, except that its internal
-structure is preserved after serialisation. More on serialisation of Objects
-can be found in the :ref:`method_discovery` section.
-
-Initialisation of an Object can be done with a brace-initializer-list as
-follows.
-
-.. code-block:: cpp
-
-    Object<int, char> o(10, 'c');
-
-Element retrieval and assignment is described below in the :ref:`Helper
-functions` section.
-
-Note that an Object, like any higher order data structure, should be passed by
-reference.
-
-Class definitions
-~~~~~~~~~~~~~~~~~
-
-.. doxygengroup:: object
-   :content-only:
-
-
 Helper functions
 ----------------
 
-Elements of a Tuple or Object can be retrieved in two ways, either via the
-``head`` and ``tail`` member variables, or using with the ``get<>()`` helper
-function.
+Elements of a Tuple can be retrieved in two ways, either via the ``head`` and
+``tail`` member variables, or using with the ``get<>()`` helper function.
 
 .. code-block:: cpp
 
@@ -89,12 +61,12 @@ the ``get<>()`` helper function.
 
 There are additional helper functions available for the creation of Tuples.
 
-The function ``pack()`` can be used to create a temporary Tuple to be used in a
+The function ``makeTuple()`` can be used to create a temporary Tuple to be used in a
 function call.
 
 .. code-block:: cpp
 
-    function(pack('a', 'b', 10));
+    function(makeTuple('a', 'b', 10));
 
 
 Functions

examples/demo/demo.ino

@@ -17,8 +17,8 @@ int inc(int a) {
   return a + 1;
 }
 
-Object<char, Object<int, char> > object(Object<char, Object<int, char> >& o) {
-  Object<char, Object<int, char> > r;
+Tuple<char, Tuple<int, char> > tuple(Tuple<char, Tuple<int, char> >& o) {
+  Tuple<char, Tuple<int, char> > r;
 
   get<0>(r) = get<0>(o) + 1;
   get<0>(get<1>(r)) = get<0>(get<1>(o)) + 1;
@@ -28,9 +28,9 @@ Object<char, Object<int, char> > object(Object<char, Object<int, char> >& o) {
 }
 
 Vector<float> vector(Vector<int>& v) {
-  Vector<float> r(v.size);
+  Vector<float> r(v.size());
 
-  for (size_t i {0}; i < v.size; i++) {
+  for (size_t i {0}; i < v.size(); i++) {
     r[i] = float(v[i]) + 0.4;
   }
 
@@ -59,7 +59,7 @@ void loop() {
     inc, F("inc: Increment a value. @a: Value. @return: a + 1."),
     setLed, F("set_led: Set LED brightness. @brightness: Brightness."),
     milliTime, F("milli_time: Report the system time. @return: System time."),
-    object, F("object: Example with objects. @o: Object. @return: Object."),
+    tuple, F("tuple: Example with tuples. @o: Tuple. @return: Tuple."),
     vector, F("cpp_vector: Example with vectors. @v: Vector. @return: Vector."),
     cVector, F("c_vector: Example with C vectors. @v: C vector. @return: Vector."));
 }

src/del.tcc

@@ -52,16 +52,8 @@ inline void rpcDel(Tuple<>*) {}
 
 /*! \ingroup del
  * \copydoc rpcDel(T*) */
-template <class... Membs>
-void rpcDel(Tuple<Membs...>* data) {
+template <class... Ts>
+void rpcDel(Tuple<Ts...>* data) {
   rpcDel(&(*data).head);
   rpcDel(&(*data).tail);
 }
-
-
-/*! \ingroup del
- * \copydoc rpcDel(T*) */
-template <class... Membs>
-void rpcDel(Object<Membs...>* data) {
-  rpcDel(dynamic_cast<Tuple<Membs...>*>(data));
-}

src/interface.tcc

@@ -137,8 +137,8 @@ void interface(Tuple<>, Args...) {}
  * \param t Tuple of input / output objects.
  * \param args Parameter pairs (function pointer, documentation).
  */
-template <class... Membs, class... Args>
-void interface(Tuple<Membs...> t, Args... args) {
+template <class... Ts, class... Args>
+void interface(Tuple<Ts...> t, Args... args) {
   interface(*t.head, args...);
   interface(t.tail, args...);
 }

src/read.tcc

@@ -129,16 +129,8 @@ inline void rpcRead(Stream&, Tuple<>*) {}
 
 /*! \ingroup read
  * \copydoc rpcRead(Stream&, T*) */
-template <class... Membs>
-void rpcRead(Stream& io, Tuple<Membs...>* data) {
+template <class... Ts>
+void rpcRead(Stream& io, Tuple<Ts...>* data) {
   rpcRead(io, &(*data).head);
   rpcRead(io, &(*data).tail);
 }
-
-
-/*! \ingroup read
- * \copydoc rpcRead(Stream&, T*) */
-template <class... Membs>
-void rpcRead(Stream& io, Object<Membs...>* data) {
-  rpcRead(io, dynamic_cast<Tuple<Membs...>*>(data));
-}

src/tuple.tcc

@@ -11,19 +11,27 @@
 /*! \ingroup tuple
  * Empty Tuple.
  */
-template <class... Membs>
-struct Tuple {};
+template <class...>
+class Tuple {};
 
 /*! \ingroup tuple
  * Non-empty Tuple.
  */
-template <class H, class... Tail>
-struct Tuple<H, Tail...> {
-  H head {};               //!< First element.
-  Tuple<Tail...> tail {};  //!< Remaining elements.
+template <class T, class... Ts>
+class Tuple<T, Ts...> {
+public:
+  Tuple() = default;
+  Tuple(T h, Ts... t);
+
+  T head {};             //!< First element.
+  Tuple<Ts...> tail {};  //!< Remaining elements.
 };
 
 
+template <class T, class... Ts>
+Tuple<T, Ts...>::Tuple(T h, Ts... t) : head {h}, tail {t...} {}
+
+
 /*!
  * Access the type of the *k*-th element in a Tuple.
  *
@@ -33,63 +41,46 @@ template <size_t, class>
 struct ElemTypeHolder_;
 
 //! \copydoc ElemTypeHolder_
-template <class H, class... Tail>
-struct ElemTypeHolder_<0, Tuple<H, Tail...> > {
-  typedef H type;
+template <class T, class... Ts>
+struct ElemTypeHolder_<0, Tuple<T, Ts...> > {
+  typedef T type;
 };
 
 //! \copydoc ElemTypeHolder_
-template <size_t k, class H, class... Tail>
-struct ElemTypeHolder_<k, Tuple<H, Tail...> > {
-  typedef typename ElemTypeHolder_<k - 1, Tuple<Tail...> >::type type;
+template <size_t k, class T, class... Ts>
+struct ElemTypeHolder_<k, Tuple<T, Ts...> > {
+  typedef typename ElemTypeHolder_<k - 1, Tuple<Ts...> >::type type;
 };
 
 
 /*! \ingroup tuplehelper
- * Get the *k*-th element of a Tuple or Object.
+ * Get the *k*-th element of a Tuple.
  *
  * This can be used for both retrieval as well as assignment.
  *
  * \param t A Tuple.
  *
  * \return Reference to the *k*-th element in `t`.
  */
-template <size_t k, class... Membs>
+template <size_t k, class... Ts>
 //! \cond
 typename enableIf<
-    k == 0, typename ElemTypeHolder_<0, Tuple<Membs...> >::type&>::type
+    k == 0, typename ElemTypeHolder_<0, Tuple<Ts...> >::type&>::type
 //! \endcond
-    get(Tuple<Membs...>& t) {
+    get(Tuple<Ts...>& t) {
   return t.head;
 }
 
-template <size_t k, class... Membs>
+template <size_t k, class... Ts>
 //! \cond
 typename enableIf<
-    k != 0, typename ElemTypeHolder_<k, Tuple<Membs...> >::type&>::type
+    k != 0, typename ElemTypeHolder_<k, Tuple<Ts...> >::type&>::type
 //! \endcond
-    get(Tuple<Membs...>& t) {
+    get(Tuple<Ts...>& t) {
   return get<k - 1>(t.tail);
 }
 
 
-//! Recursion terminator for `fill()`.
-inline void fill(Tuple<>) {}
-
-/*!
- * Fill a Tuple.
- *
- * \param t Tuple.
- * \param head First element.
- * \param tail Remaining elements.
- */
-template <class H, class... Tail>
-void fill(Tuple<H, Tail...>& t, H head, Tail... tail) {
-  t.head = head;
-  fill(t.tail, tail...);
-}
-
-
 /*! \ingroup tuplehelper
  * Make a Tuple from a parameter pack.
  *
@@ -98,25 +89,7 @@ void fill(Tuple<H, Tail...>& t, H head, Tail... tail) {
  * \return Tuple containing `args`.
  */
 template <class... Args>
-Tuple<Args...> pack(Args... args) {
-  Tuple<Args...> t;
-  fill(t, args...);
-
+Tuple<Args...> makeTuple(Args... args) {
+  Tuple<Args...> t {args...};
   return t;
 }
-
-
-/*! \ingroup object
- * Object.
- */
-template <class... Membs>
-struct Object : Tuple<Membs...> {
-  /*
-   * Preferably this would have been an alias, but this is not supported in
-   * C++11.
-   */
-  Object() {}
-  Object(Membs... args) : Tuple<Membs...>() {
-    fill(*dynamic_cast<Tuple<Membs...>*>(this), args...);
-  }
-};

src/types.tcc

@@ -132,32 +132,25 @@ inline void rpcTypeOf(Stream& io, double) {
 }
 
 
-//! Recursion terminator for `rpcTypeOf(Tuple&)`.
-inline void rpcTypeOf(Stream&, Tuple<>&) {}
+//! Recursion terminator for `rpcTypeOf_(Tuple&)`.
+inline void rpcTypeOf_(Stream&, Tuple<>&) {}
 
 /*! \ingroup types
  * Get the types of all members of a Tuple.
  *
  * \param io Stream.
  * \param t Tuple.
  */
-template <class... Membs>
-void rpcTypeOf(Stream& io, Tuple<Membs...>& t) {
+template <class... Ts>
+void rpcTypeOf_(Stream& io, Tuple<Ts...>& t) {
   rpcTypeOf(io, t.head);
-  rpcTypeOf(io, t.tail);
+  rpcTypeOf_(io, t.tail);
 }
 
-
-/*! \ingroup types
- * Get the types of all members of an Object.
- *
- * \param io Stream.
- * \param t Object.
- */
-template <class... Membs>
-void rpcTypeOf(Stream& io, Object<Membs...>& o) {
+template <class... Ts>
+void rpcTypeOf(Stream& io, Tuple<Ts...>& t) {
   rpcPrint(io, '(');
-  rpcTypeOf(io, dynamic_cast<Tuple<Membs...>&>(o));
+  rpcTypeOf_(io, t);
   rpcPrint(io, ')');
 }
 

src/write.tcc

@@ -67,16 +67,8 @@ inline void rpcWrite(Stream&, Tuple<>*) {}
 
 /*! \ingroup write
  * \copydoc rpcWrite(Stream&, T*) */
-template <class... Membs>
-void rpcWrite(Stream& io, Tuple<Membs...>* data) {
+template <class... Ts>
+void rpcWrite(Stream& io, Tuple<Ts...>* data) {
   rpcWrite(io, &(*data).head);
   rpcWrite(io, &(*data).tail);
 }
-
-
-/*! \ingroup write
- * \copydoc rpcWrite(Stream&, T*) */
-template <class... Membs>
-void rpcWrite(Stream& io, Object<Membs...>* data) {
-  rpcWrite(io, dynamic_cast<Tuple<Membs...>*>(data));
-}

tests/test_interface.cc

@@ -29,12 +29,12 @@ TEST_CASE("Describe class member function", "[describe][class]") {
 
   // Empty description.
   Serial.reset();
-  describe_(Serial, pack(&c, &C::f), "");
+  describe_(Serial, makeTuple(&c, &C::f), "");
   REQUIRE(Serial.inspect<String>() == ":;");
 
   // Non-empty description.
   Serial.reset();
-  describe_(Serial, pack(&c, &C::f), "Function description.");
+  describe_(Serial, makeTuple(&c, &C::f), "Function description.");
   REQUIRE(Serial.inspect<String>() == ":;Function description.");
 }
 
@@ -49,13 +49,13 @@ TEST_CASE("Multiple functions", "[describe][class]") {
 
   // Normal function first.
   Serial.reset();
-  describe_(Serial, f, "f", pack(&c, &C::f), "C::f");
+  describe_(Serial, f, "f", makeTuple(&c, &C::f), "C::f");
   REQUIRE(Serial.inspect<String>() == ":;f");
   REQUIRE(Serial.inspect<String>() == ":;C::f");
 
   // Class member function first.
   Serial.reset();
-  describe_(Serial, pack(&c, &C::f), "C::f", f, "f");
+  describe_(Serial, makeTuple(&c, &C::f), "C::f", f, "f");
   REQUIRE(Serial.inspect<String>() == ":;C::f");
   REQUIRE(Serial.inspect<String>() == ":;f");
 }
@@ -135,7 +135,7 @@ TEST_CASE("RPC call function x", "[call][basic]") {
   Serial.reset();
   Serial.prepare('\0');
   Serial.prepare('\0');
-  interface(pack(&Serial, &Serial), S::f, "");
+  interface(makeTuple(&Serial, &Serial), S::f, "");
   REQUIRE(Serial.inspect<short int>() == 2);
   REQUIRE(Serial.inspect<short int>() == 2);
   REQUIRE(Serial.rx == 2 * (sizeof(byte) + sizeof(int)));