Minor style changes.

Author: jfjlaros

examples/demo/demo.ino

@@ -17,20 +17,20 @@ int inc(int a) {
   return a + 1;
 }
 
-Tuple<char, Tuple<int, char> > tuple(Tuple<char, Tuple<int, char> >& o) {
+Tuple<char, Tuple<int, char> > tuple(Tuple<char, Tuple<int, char> >& t) {
   Tuple<char, Tuple<int, char> > r;
 
-  get<0>(r) = get<0>(o) + 1;
-  get<0>(get<1>(r)) = get<0>(get<1>(o)) + 1;
-  get<1>(get<1>(r)) = get<1>(get<1>(o)) + 1;
+  get<0>(r) = get<0>(t) + 1;
+  get<0>(get<1>(r)) = get<0>(get<1>(t)) + 1;
+  get<1>(get<1>(r)) = get<1>(get<1>(t)) + 1;
 
   return r;
 }
 
 Vector<float> vector(Vector<int>& v) {
   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;
   }
 

src/del.tcc

@@ -32,7 +32,7 @@ void rpcDel(T const** data) {
  * \copydoc rpcDel(T*) */
 template <class T>
 void rpcDel(T*** data) {
-  for (size_t i {0}; (*data)[i]; i++) {
+  for (size_t i {0}; (*data)[i]; ++i) {
     rpcDel(&(*data)[i]);
   }
 

src/helper.tcc

@@ -10,5 +10,5 @@ struct enableIf {};
 
 template <class T>
 struct enableIf<true, T> {
-  typedef T type;
+  using type = T;
 };

src/interface.tcc

@@ -42,8 +42,8 @@ inline void describe_(Stream& io) {
  * \param doc Function documentation.
  * \param args Remaining parameters.
  */
-template <class F, class D, class... Args>
-void describe_(Stream& io, F f, D doc, Args... args) {
+template <class F, class D, class... Ts>
+void describe_(Stream& io, F f, D doc, Ts... args) {
   /*
    * The first two parameters `f` and `doc` are isolated and passed to
    * `writeDescription_()`. Then a recursive call to process the remaining
@@ -53,9 +53,9 @@ void describe_(Stream& io, F f, D doc, Args... args) {
   describe_(io, args...);
 }
 
-//! \copydoc describe_(Stream&, F, D, Args...)
-template <class U, class V, class D, class... Args>
-void describe_(Stream& io, Tuple<U, V> t, D doc, Args... args) {
+//! \copydoc describe_(Stream&, F, D, Ts...)
+template <class U, class V, class D, class... Ts>
+void describe_(Stream& io, Tuple<U, V> t, D doc, Ts... args) {
   writeDescription_(io, t.tail.head, doc);
   describe_(io, args...);
 }
@@ -74,8 +74,8 @@ inline void select_(Stream&, uint8_t, uint8_t) {}
  * \param - Function documentation.
  * \param args Remaining parameters.
  */
-template <class F, class D, class... Args>
-void select_(Stream& io, uint8_t number, uint8_t depth, F f, D, Args... args) {
+template <class F, class D, class... Ts>
+void select_(Stream& io, uint8_t number, uint8_t depth, F f, D, Ts... args) {
   /*
    * The parameter `f` and its documentation string are isolated, discarding
    * the latter. If the selected function is encountered (i.e., if `depth`
@@ -100,8 +100,8 @@ void select_(Stream& io, uint8_t number, uint8_t depth, F f, D, Args... args) {
  * \param io Stream.
  * \param args Parameter pairs (function pointer, documentation).
  */
-template <class... Args>
-void interface(Stream& io, Args... args) {
+template <class... Ts>
+void interface(Stream& io, Ts... args) {
   /*
    * One byte is read into `command`, if the value equals `LIST_REQ_`, the list
    * of functions is described. Otherwise, the function indexed by `command` is
@@ -123,22 +123,22 @@ void interface(Stream& io, Args... args) {
 }
 
 //! Recursion terminator for `interface()`.
-template <class... Args>
-void interface(Tuple<>, Args...) {}
+template <class... Ts>
+void interface(Tuple<>, Ts...) {}
 
 /*! \ingroup interface
  * Multiple RPC interfaces.
  *
  * Similar to the standard interface , but with support for multiple I/O
  * interfaces, passed as Tuple `t`.
  *
- * \sa interface(Stream&, Args...)
+ * \sa interface(Stream&, Ts...)
  *
  * \param t Tuple of input / output objects.
  * \param args Parameter pairs (function pointer, documentation).
  */
-template <class... Ts, class... Args>
-void interface(Tuple<Ts...> t, Args... args) {
+template <class... Ts, class... Us>
+void interface(Tuple<Ts...> t, Us... args) {
   interface(*t.head, args...);
   interface(t.tail, args...);
 }

src/print.tcc

@@ -20,11 +20,8 @@ void rpcPrint(Stream& io, T data) {
 /*! \ingroup print
  * \copydoc rpcPrint(Stream&, T) */
 inline void rpcPrint(Stream& io, char* data) {
-  size_t i {0};
-
-  while (data[i]) {
+  for (size_t i {0}; data[i]; ++i) {
     rpcPrint(io, data[i]);
-    i++;
   }
 }
 
@@ -44,12 +41,8 @@ inline void rpcPrint(Stream& io, String& data) {
  * \copydoc rpcPrint(Stream&, T) */
 inline void rpcPrint(Stream& io, __FlashStringHelper const* data) {
   char const* p {reinterpret_cast<char const*>(data)};
-  uint8_t c {pgm_read_byte(p)};
-
-  while (c) {
+  for (uint8_t c {pgm_read_byte(p)}; c; c = pgm_read_byte(++p)) {
     rpcPrint(io, c);
-    p++;
-    c = pgm_read_byte(p);
   }
 }
 
@@ -61,8 +54,8 @@ inline void rpcPrint(Stream& io, __FlashStringHelper const* data) {
  * \param data Value to be printed.
  * \param args Remaining values.
  */
-template <class H, class... Tail>
-void rpcPrint(Stream& io, H data, Tail... args) {
+template <class T, class... Ts>
+void rpcPrint(Stream& io, T data, Ts... args) {
   rpcPrint(io, data);
   rpcPrint(io, args...);
 }

src/read.tcc

@@ -33,7 +33,7 @@ inline void rpcRead(Stream& io, char** data) {
   *data = new char[1];
   rpcRead(io, *data);
 
-  for (size_t size {1}; (*data)[size - 1]; size++) {
+  for (size_t size {1}; (*data)[size - 1]; ++size) {
     char* data_ {new char[size + 1]};
     memcpy(data_, *data, size);
     delete[] *data;
@@ -71,7 +71,7 @@ void rpcRead(Stream& io, Vector<T>* data) {
   rpcRead(io, &size);
 
   (*data).resize(size);
-  for (size_t i {0}; i < (*data).size(); i++) {
+  for (size_t i {0}; i < (*data).size(); ++i) {
     rpcRead(io, &(*data)[i]);
   }
 }
@@ -84,7 +84,7 @@ void rpcRead(Stream& io, T** data) {
   rpcRead(io, &size);
 
   *data = new T[size];
-  for (size_t i {0}; i < size; i++) {
+  for (size_t i {0}; i < size; ++i) {
     rpcRead(io, *data + i);
   }
 }
@@ -96,7 +96,7 @@ void rpcRead(Stream& io, Array<T, n>* data) {
   size_t size;
   rpcRead(io, &size);
 
-  for (size_t i {0}; i < min(size, n); i++) {
+  for (size_t i {0}; i < min(size, n); ++i) {
     rpcRead(io, &(*data)[i]);
   }
 }
@@ -117,7 +117,7 @@ void rpcRead(Stream& io, T*** data) {
   rpcRead(io, &size);
   *data = new T*[size + 1];
 
-  for (size_t i {0}; i < size; i++) {
+  for (size_t i {0}; i < size; ++i) {
     rpcRead(io, *data + i);
   }
   (*data)[size] = nullptr;

src/rpcCall.tcc

@@ -15,14 +15,13 @@
  * \param f Function pointer.
  * \param args Parameter pack for `f`.
  */
-template <class R, class... FArgs, class... Args>
-void call_(Stream& io, void (*)(), R (*f)(FArgs...), Args&... args) {
+template <class T, class... Ts, class... Us>
+void call_(Stream& io, void (*)(), T (*f)(Ts...), Us&... args) {
   /*
    * All parameters have been collected since function pointer `*f_` has no
    * parameter types. All values are now present in the `args` parameter pack.
    */
-  R data {f(args...)};
-
+  T data {f(args...)};
   rpcWrite(io, &data);
 }
 
@@ -35,24 +34,23 @@ void call_(Stream& io, void (*)(), R (*f)(FArgs...), Args&... args) {
  *   to a class method.
  * \param args Parameter pack for `f`.
  */
-template <class C, class P, class R, class... FArgs, class... Args>
+template <class C, class P, class T, class... Ts, class... Us>
 void call_(
-    Stream& io, void (*)(), Tuple<C*, R (P::*)(FArgs...)> t, Args&... args) {
-  R data {(*t.head.*t.tail.head)(args...)};
-
+    Stream& io, void (*)(), Tuple<C*, T (P::*)(Ts...)> t, Us&... args) {
+  T data {(*t.head.*t.tail.head)(args...)};
   rpcWrite(io, &data);
 }
 
-//! \copydoc call_(Stream&, void (*)(), R (*)(FArgs...), Args&...)
-template <class... FArgs, class... Args>
-void call_(Stream&, void (*)(), void (*f)(FArgs...), Args&... args) {
+//! \copydoc call_(Stream&, void (*)(), T (*)(Ts...), Us&...)
+template <class... Ts, class... Us>
+void call_(Stream&, void (*)(), void (*f)(Ts...), Us&... args) {
   f(args...);
 }
 
-//! \copydoc call_(Stream&, void (*)(), R (*)(FArgs...), Args&...)
-template <class C, class P, class... FArgs, class... Args>
+//! \copydoc call_(Stream&, void (*)(), T (*)(Ts...), Us&...)
+template <class C, class P, class... Ts, class... Us>
 void call_(
-    Stream&, void (*)(), Tuple<C*, void (P::*)(FArgs...)> t, Args&... args) {
+    Stream&, void (*)(), Tuple<C*, void (P::*)(Ts...)> t, Us&... args) {
   (*t.head.*t.tail.head)(args...);
 }
 
@@ -65,27 +63,27 @@ void call_(
  * \param f Function pointer.
  * \param args Parameter pack for `f`.
  */
-template <class H, class... Tail, class F, class... Args>
-void call_(Stream& io, void (*)(H, Tail...), F f, Args&... args) {
+template <class T, class... Ts, class F, class... Us>
+void call_(Stream& io, void (*)(T, Ts...), F f, Us&... args) {
   /* 
-   * The first parameter type `H` is isolated from the function pointer. This
+   * The first parameter type `T` is isolated from the function pointer. This
    * type is used to instantiate the variable `data`, which is used to receive
-   * `sizeof(H)` bytes. This value is passed recursively to `call_()` function,
-   * adding it to the `args` parameter pack. The first parameter type `H` is
+   * `sizeof(T)` bytes. This value is passed recursively to `call_()` function,
+   * adding it to the `args` parameter pack. The first parameter type `T` is
    * removed from the function pointer in the recursive call.
    */ 
-  H data;
+  T data;
   rpcRead(io, &data);
 
-  void (*f_)(Tail...) {};
+  void (*f_)(Ts...) {};
   call_(io, f_, f, args..., data);
   rpcDel(&data);
 }
 
-//! \copydoc call_(Stream&, void (*)(H, Tail...), F, Args&...)
-template <class H, class... Tail, class F, class... Args>
-void call_(Stream& io, void (*)(H&, Tail...), F f, Args&... args) {
-  void (*f_)(H, Tail...) {};
+//! \copydoc call_(Stream&, void (*)(T, Ts...), F, Us&...)
+template <class T, class... Ts, class F, class... Us>
+void call_(Stream& io, void (*)(T&, Ts...), F f, Us&... args) {
+  void (*f_)(T, Ts...) {};
   call_(io, f_, f, args...);
 }
 
@@ -99,28 +97,28 @@ void call_(Stream& io, void (*)(H&, Tail...), F f, Args&... args) {
  * \param io Stream.
  * \param f Function pointer.
  */
-template <class R, class... FArgs>
-void rpcCall(Stream& io, R (*f)(FArgs...)) {
+template <class T, class... Ts>
+void rpcCall(Stream& io, T (*f)(Ts...)) {
   /*
    * A dummy function pointer is prepared, which will be used to isolate
    * parameter types. The return type of this function pointer is removed to
    * avoid unneeded template expansion.
    */
-  void (*f_)(FArgs...) {};
+  void (*f_)(Ts...) {};
   call_(io, f_, f);
 }
 
 /*! \ingroup call
  * Call a class method.
  *
- * \sa rpcCall(Stream&, R (*)(FArgs...))
+ * \sa rpcCall(Stream&, T (*)(Ts...))
  *
  * \param io Stream.
  * \param t Tuple consisting of a pointer to a class instance and a pointer
  *   to a class method.
  */
-template <class C, class P ,class R, class... FArgs>
-void rpcCall(Stream& io, Tuple<C*, R (P::*)(FArgs...)> t) {
-  void (*f_)(FArgs...) {};
+template <class C, class P, class T, class... Ts>
+void rpcCall(Stream& io, Tuple<C*, T (P::*)(Ts...)> t) {
+  void (*f_)(Ts...) {};
   call_(io, f_, t);
 }