Changed spacing around pointers and references.

peterpolidoro · peterpolidoro · commit adf5e5fc0b0d · 2016-09-26T16:09:27.000-04:00
diff --git a/Array.h b/Array.h
@@ -23,43 +23,43 @@ class Array
 {
 public:
   Array();
-  Array(const T &value);
+  Array(const T & value);
   template <typename U, size_t N>
   Array(const U (&values)[N]);
   template <typename U, size_t N>
-  Array(const Array<U,N> &values);
-  T& operator[](const size_t i);
-  T& at(const size_t i);
-  T& front();
-  T& back();
+  Array(const Array<U,N> & values);
+  T & operator[](const size_t i);
+  T & at(const size_t i);
+  T & front();
+  T & back();
   void clear();
   template <typename U>
-  void fill(const U &value);
+  void fill(const U & value);
   template <typename U, size_t N>
   void fill(const U (&values)[N]);
   template <typename U, size_t N>
-  void fill(const Array<U,N> &values);
+  void fill(const Array<U,N> & values);
   template <typename U>
-  void assign(const size_t n, const U &value);
+  void assign(const size_t n, const U & value);
   template <typename U, size_t N>
   void assign(const size_t n, const U (&values)[N]);
   template <typename U, size_t N>
-  void assign(const size_t n, const Array<U,N> &values);
-  void push_back(const T &value);
+  void assign(const size_t n, const Array<U,N> & values);
+  void push_back(const T & value);
   void pop_back();
   size_t size();
   size_t max_size();
   bool empty();
   bool full();
-  T* data();
+  T * data();
 
 private:
   T values_[MAX_SIZE];
   size_t size_;
 };
 
 template <typename T, size_t MAX_SIZE>
-inline Print &operator <<(Print &stream, const Array<T,MAX_SIZE> &array)
+inline Print & operator <<(Print & stream, const Array<T,MAX_SIZE> & array)
 {
   stream.print("[");
   for (int i=0; i<array.size(); i++)
diff --git a/ArrayDefinitions.h b/ArrayDefinitions.h
@@ -19,7 +19,7 @@ Array<T, MAX_SIZE>::Array()
 }
 
 template <typename T, size_t MAX_SIZE>
-Array<T, MAX_SIZE>::Array(const T &value)
+Array<T, MAX_SIZE>::Array(const T & value)
 {
   size_ = 0;
   fill(value);
@@ -35,32 +35,32 @@ Array<T, MAX_SIZE>::Array(const U (&values)[N])
 
 template <typename T, size_t MAX_SIZE>
 template <typename U, size_t N>
-Array<T, MAX_SIZE>::Array(const Array<U,N> &values)
+Array<T, MAX_SIZE>::Array(const Array<U,N> & values)
 {
   size_ = 0;
   fill(values);
 }
 
 template <typename T, size_t MAX_SIZE>
-T& Array<T, MAX_SIZE>::operator[](const size_t i)
+T & Array<T, MAX_SIZE>::operator[](const size_t i)
 {
   return values_[i];
 }
 
 template <typename T, size_t MAX_SIZE>
-T& Array<T, MAX_SIZE>::at(const size_t i)
+T & Array<T, MAX_SIZE>::at(const size_t i)
 {
   return values_[i];
 }
 
 template <typename T, size_t MAX_SIZE>
-T& Array<T, MAX_SIZE>::front()
+T & Array<T, MAX_SIZE>::front()
 {
   return values_[0];
 }
 
 template <typename T, size_t MAX_SIZE>
-T& Array<T, MAX_SIZE>::back()
+T & Array<T, MAX_SIZE>::back()
 {
   return values_[size_-1];
 }
@@ -73,7 +73,7 @@ void Array<T, MAX_SIZE>::clear()
 
 template <typename T, size_t MAX_SIZE>
 template <typename U>
-void Array<T, MAX_SIZE>::fill(const U &value)
+void Array<T, MAX_SIZE>::fill(const U & value)
 {
   assign(MAX_SIZE,value);
 }
@@ -87,14 +87,14 @@ void Array<T, MAX_SIZE>::fill(const U (&values)[N])
 
 template <typename T, size_t MAX_SIZE>
 template <typename U, size_t N>
-void Array<T, MAX_SIZE>::fill(const Array<U,N> &values)
+void Array<T, MAX_SIZE>::fill(const Array<U,N> & values)
 {
   assign(values.size(),values);
 }
 
 template <typename T, size_t MAX_SIZE>
 template <typename U>
-void Array<T, MAX_SIZE>::assign(const size_t n, const U &value)
+void Array<T, MAX_SIZE>::assign(const size_t n, const U & value)
 {
   size_t assign_size = ((n < MAX_SIZE) ? n : MAX_SIZE);
   size_ = assign_size;
@@ -119,7 +119,7 @@ void Array<T, MAX_SIZE>::assign(const size_t n, const U (&values)[N])
 
 template <typename T, size_t MAX_SIZE>
 template <typename U, size_t N>
-void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> &values)
+void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> & values)
 {
   size_t n_smallest = ((n < values.size()) ? n : values.size());
   size_t assign_size = ((n_smallest < MAX_SIZE) ? n_smallest : MAX_SIZE);
@@ -131,7 +131,7 @@ void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> &values)
 }
 
 template <typename T, size_t MAX_SIZE>
-void Array<T, MAX_SIZE>::push_back(const T &value)
+void Array<T, MAX_SIZE>::push_back(const T & value)
 {
   if (size_ < MAX_SIZE)
   {
@@ -173,7 +173,7 @@ bool Array<T, MAX_SIZE>::full()
 }
 
 template <typename T, size_t MAX_SIZE>
-T* Array<T, MAX_SIZE>::data()
+T * Array<T, MAX_SIZE>::data()
 {
   return values_;
 }
diff --git a/examples/ArrayTester/ArrayTester.ino b/examples/ArrayTester/ArrayTester.ino
@@ -23,7 +23,7 @@ Array<int,ELEMENT_COUNT> generateArray()
   return array;
 }
 
-Array<int,ELEMENT_COUNT> doubleElements(Array<int,ELEMENT_COUNT> &array)
+Array<int,ELEMENT_COUNT> doubleElements(Array<int,ELEMENT_COUNT> & array)
 {
   Array<int,ELEMENT_COUNT> array_doubled;
   for (int i=0; i<ELEMENT_COUNT; i++)
@@ -109,7 +109,7 @@ void setup()
   Serial << array_copy3.max_size() << endl;
 
   // get pointer to raw data
-  size_t *array_copy3_ptr = array_copy3.data();
+  size_t * array_copy3_ptr = array_copy3.data();
   size_t index = 2;
   if (index < array_copy3.size())
   {
diff --git a/examples/MultiArrayPrinter/Device.h b/examples/MultiArrayPrinter/Device.h
@@ -24,7 +24,7 @@ class Device
   Device();
   static void print();
   template<typename E>
-  static void printRandomObject(const E &obj);
+  static void printRandomObject(const E & obj);
 private:
   static Server<T,
                 X_SIZE+RESERVED_X_COUNT,
diff --git a/examples/MultiArrayPrinter/DeviceDefinitions.h b/examples/MultiArrayPrinter/DeviceDefinitions.h
@@ -31,7 +31,7 @@ template <typename T,
           unsigned int Y_SIZE,
           unsigned int Z_SIZE>
 template<typename E>
-void Device<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E &obj)
+void Device<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E & obj)
 {
   server_.printRandomObject(obj);
 }
diff --git a/examples/MultiArrayPrinter/Server.h b/examples/MultiArrayPrinter/Server.h
@@ -20,13 +20,13 @@ template <typename T,
 class Server
 {
 public:
-  Server(HardwareSerial &serial=Serial);
-  void setSerial(HardwareSerial &serial);
+  Server(HardwareSerial & serial=Serial);
+  void setSerial(HardwareSerial & serial);
   void print();
   template<typename E>
-  void printRandomObject(const E &obj);
+  void printRandomObject(const E & obj);
 private:
-  HardwareSerial *serial_ptr_;
+  HardwareSerial * serial_ptr_;
   Array<T, X_SIZE+constants::RESERVED_X_COUNT> x_;
   Array<T, Y_SIZE+constants::RESERVED_Y_COUNT> y_;
   Array<T, Z_SIZE+constants::RESERVED_Z_COUNT> z_;
diff --git a/examples/MultiArrayPrinter/ServerDefinitions.h b/examples/MultiArrayPrinter/ServerDefinitions.h
@@ -12,7 +12,7 @@ template <typename T,
           unsigned int X_SIZE,
           unsigned int Y_SIZE,
           unsigned int Z_SIZE>
-Server<T,X_SIZE,Y_SIZE,Z_SIZE>::Server(HardwareSerial &serial)
+Server<T,X_SIZE,Y_SIZE,Z_SIZE>::Server(HardwareSerial & serial)
 {
   setSerial(serial);
 }
@@ -21,7 +21,7 @@ template <typename T,
           unsigned int X_SIZE,
           unsigned int Y_SIZE,
           unsigned int Z_SIZE>
-void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::setSerial(HardwareSerial &serial)
+void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::setSerial(HardwareSerial & serial)
 {
   serial_ptr_ = &serial;
 }
@@ -47,7 +47,7 @@ template <typename T,
           unsigned int Y_SIZE,
           unsigned int Z_SIZE>
 template <typename E>
-void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E &obj)
+void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E & obj)
 {
   *serial_ptr_ << obj << endl;
 }

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ Array<T, MAX_SIZE>::Array()`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`template <typename T, size_t MAX_SIZE>`
`22`		`-Array<T, MAX_SIZE>::Array(const T &value)`
	`22`	`+Array<T, MAX_SIZE>::Array(const T & value)`
`23`	`23`	`{`
`24`	`24`	`size_ = 0;`
`25`	`25`	`fill(value);`
`@@ -35,32 +35,32 @@ Array<T, MAX_SIZE>::Array(const U (&values)[N])`
`35`	`35`
`36`	`36`	`template <typename T, size_t MAX_SIZE>`
`37`	`37`	`template <typename U, size_t N>`
`38`		`-Array<T, MAX_SIZE>::Array(const Array<U,N> &values)`
	`38`	`+Array<T, MAX_SIZE>::Array(const Array<U,N> & values)`
`39`	`39`	`{`
`40`	`40`	`size_ = 0;`
`41`	`41`	`fill(values);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`template <typename T, size_t MAX_SIZE>`
`45`		`-T& Array<T, MAX_SIZE>::operator[](const size_t i)`
	`45`	`+T & Array<T, MAX_SIZE>::operator[](const size_t i)`
`46`	`46`	`{`
`47`	`47`	`return values_[i];`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`template <typename T, size_t MAX_SIZE>`
`51`		`-T& Array<T, MAX_SIZE>::at(const size_t i)`
	`51`	`+T & Array<T, MAX_SIZE>::at(const size_t i)`
`52`	`52`	`{`
`53`	`53`	`return values_[i];`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`template <typename T, size_t MAX_SIZE>`
`57`		`-T& Array<T, MAX_SIZE>::front()`
	`57`	`+T & Array<T, MAX_SIZE>::front()`
`58`	`58`	`{`
`59`	`59`	`return values_[0];`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`template <typename T, size_t MAX_SIZE>`
`63`		`-T& Array<T, MAX_SIZE>::back()`
	`63`	`+T & Array<T, MAX_SIZE>::back()`
`64`	`64`	`{`
`65`	`65`	`return values_[size_-1];`
`66`	`66`	`}`
`@@ -73,7 +73,7 @@ void Array<T, MAX_SIZE>::clear()`
`73`	`73`
`74`	`74`	`template <typename T, size_t MAX_SIZE>`
`75`	`75`	`template <typename U>`
`76`		`-void Array<T, MAX_SIZE>::fill(const U &value)`
	`76`	`+void Array<T, MAX_SIZE>::fill(const U & value)`
`77`	`77`	`{`
`78`	`78`	`assign(MAX_SIZE,value);`
`79`	`79`	`}`
`@@ -87,14 +87,14 @@ void Array<T, MAX_SIZE>::fill(const U (&values)[N])`
`87`	`87`
`88`	`88`	`template <typename T, size_t MAX_SIZE>`
`89`	`89`	`template <typename U, size_t N>`
`90`		`-void Array<T, MAX_SIZE>::fill(const Array<U,N> &values)`
	`90`	`+void Array<T, MAX_SIZE>::fill(const Array<U,N> & values)`
`91`	`91`	`{`
`92`	`92`	`assign(values.size(),values);`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`template <typename T, size_t MAX_SIZE>`
`96`	`96`	`template <typename U>`
`97`		`-void Array<T, MAX_SIZE>::assign(const size_t n, const U &value)`
	`97`	`+void Array<T, MAX_SIZE>::assign(const size_t n, const U & value)`
`98`	`98`	`{`
`99`	`99`	`size_t assign_size = ((n < MAX_SIZE) ? n : MAX_SIZE);`
`100`	`100`	`size_ = assign_size;`
`@@ -119,7 +119,7 @@ void Array<T, MAX_SIZE>::assign(const size_t n, const U (&values)[N])`
`119`	`119`
`120`	`120`	`template <typename T, size_t MAX_SIZE>`
`121`	`121`	`template <typename U, size_t N>`
`122`		`-void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> &values)`
	`122`	`+void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> & values)`
`123`	`123`	`{`
`124`	`124`	`size_t n_smallest = ((n < values.size()) ? n : values.size());`
`125`	`125`	`size_t assign_size = ((n_smallest < MAX_SIZE) ? n_smallest : MAX_SIZE);`
`@@ -131,7 +131,7 @@ void Array<T, MAX_SIZE>::assign(const size_t n, const Array<U,N> &values)`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`template <typename T, size_t MAX_SIZE>`
`134`		`-void Array<T, MAX_SIZE>::push_back(const T &value)`
	`134`	`+void Array<T, MAX_SIZE>::push_back(const T & value)`
`135`	`135`	`{`
`136`	`136`	`if (size_ < MAX_SIZE)`
`137`	`137`	`{`
`@@ -173,7 +173,7 @@ bool Array<T, MAX_SIZE>::full()`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`template <typename T, size_t MAX_SIZE>`
`176`		`-T* Array<T, MAX_SIZE>::data()`
	`176`	`+T * Array<T, MAX_SIZE>::data()`
`177`	`177`	`{`
`178`	`178`	`return values_;`
`179`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ Array<int,ELEMENT_COUNT> generateArray()`
`23`	`23`	`return array;`
`24`	`24`	`}`
`25`	`25`
`26`		`-Array<int,ELEMENT_COUNT> doubleElements(Array<int,ELEMENT_COUNT> &array)`
	`26`	`+Array<int,ELEMENT_COUNT> doubleElements(Array<int,ELEMENT_COUNT> & array)`
`27`	`27`	`{`
`28`	`28`	`Array<int,ELEMENT_COUNT> array_doubled;`
`29`	`29`	`for (int i=0; i<ELEMENT_COUNT; i++)`
`@@ -109,7 +109,7 @@ void setup()`
`109`	`109`	`Serial << array_copy3.max_size() << endl;`
`110`	`110`
`111`	`111`	`// get pointer to raw data`
`112`		`- size_t *array_copy3_ptr = array_copy3.data();`
	`112`	`+ size_t * array_copy3_ptr = array_copy3.data();`
`113`	`113`	`size_t index = 2;`
`114`	`114`	`if (index < array_copy3.size())`
`115`	`115`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ template <typename T,`
`31`	`31`	`unsigned int Y_SIZE,`
`32`	`32`	`unsigned int Z_SIZE>`
`33`	`33`	`template<typename E>`
`34`		`-void Device<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E &obj)`
	`34`	`+void Device<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E & obj)`
`35`	`35`	`{`
`36`	`36`	`server_.printRandomObject(obj);`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ template <typename T,`
`12`	`12`	`unsigned int X_SIZE,`
`13`	`13`	`unsigned int Y_SIZE,`
`14`	`14`	`unsigned int Z_SIZE>`
`15`		`-Server<T,X_SIZE,Y_SIZE,Z_SIZE>::Server(HardwareSerial &serial)`
	`15`	`+Server<T,X_SIZE,Y_SIZE,Z_SIZE>::Server(HardwareSerial & serial)`
`16`	`16`	`{`
`17`	`17`	`setSerial(serial);`
`18`	`18`	`}`
`@@ -21,7 +21,7 @@ template <typename T,`
`21`	`21`	`unsigned int X_SIZE,`
`22`	`22`	`unsigned int Y_SIZE,`
`23`	`23`	`unsigned int Z_SIZE>`
`24`		`-void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::setSerial(HardwareSerial &serial)`
	`24`	`+void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::setSerial(HardwareSerial & serial)`
`25`	`25`	`{`
`26`	`26`	`serial_ptr_ = &serial;`
`27`	`27`	`}`
`@@ -47,7 +47,7 @@ template <typename T,`
`47`	`47`	`unsigned int Y_SIZE,`
`48`	`48`	`unsigned int Z_SIZE>`
`49`	`49`	`template <typename E>`
`50`		`-void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E &obj)`
	`50`	`+void Server<T,X_SIZE,Y_SIZE,Z_SIZE>::printRandomObject(const E & obj)`
`51`	`51`	`{`
`52`	`52`	`*serial_ptr_ << obj << endl;`
`53`	`53`	`}`