Encapsulate everything in namespace arduino

facchinm · facchinm · commit fc0c12d7faf4 · 2019-11-13T16:23:05.000+01:00
This will help integrating with other C++ frameworks declaring the same classes (String/Serial/...)
diff --git a/api/Client.h b/api/Client.h
@@ -22,6 +22,8 @@
 #include "Stream.h"
 #include "IPAddress.h"
 
+namespace arduino {
+
 class Client : public Stream {
 
 public:
@@ -41,3 +43,4 @@ class Client : public Stream {
   uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
 };
 
+}
diff --git a/api/HardwareI2C.h b/api/HardwareI2C.h
@@ -21,6 +21,8 @@
 #include <inttypes.h>
 #include "Stream.h"
 
+namespace arduino {
+
 class HardwareI2C : public Stream
 {
   public:
@@ -41,3 +43,5 @@ class HardwareI2C : public Stream
     virtual void onRequest(void(*)(void)) = 0;
 };
 
+}
+
diff --git a/api/HardwareSerial.h b/api/HardwareSerial.h
@@ -21,6 +21,8 @@
 #include <inttypes.h>
 #include "Stream.h"
 
+namespace arduino {
+
 // XXX: Those constants should be defined as const int / enums?
 // XXX: shall we use namespaces too?
 #define SERIAL_PARITY_EVEN   (0x1ul)
@@ -100,3 +102,4 @@ class HardwareSerial : public Stream
 // XXX: Are we keeping the serialEvent API?
 extern void serialEventRun(void) __attribute__((weak));
 
+}
diff --git a/api/IPAddress.cpp b/api/IPAddress.cpp
@@ -20,6 +20,8 @@
 #include "IPAddress.h"
 #include "Print.h"
 
+using namespace arduino;
+
 IPAddress::IPAddress()
 {
     _address.dword = 0;
diff --git a/api/IPAddress.h b/api/IPAddress.h
@@ -23,6 +23,8 @@
 #include "Printable.h"
 #include "String.h"
 
+namespace arduino {
+
 // A class to make it easier to handle and pass around IP addresses
 
 class IPAddress : public Printable {
@@ -74,4 +76,4 @@ class IPAddress : public Printable {
 };
 
 extern const IPAddress INADDR_NONE;
-
+}
diff --git a/api/Interrupts.h b/api/Interrupts.h
@@ -7,6 +7,8 @@
 #include <stdint.h>
 #include "Common.h"
 
+namespace arduino {
+
 template <typename T>
 using voidTemplateFuncPtrParam =  void (*)(T param);
 
@@ -37,5 +39,6 @@ template<typename T> void attachInterrupt(pin_size_t interruptNum, voidTemplateF
   attachInterruptParam(interruptNum, (voidFuncPtrParam)userFunc, mode, (void*)param);
 }
 
+}
 #endif
 #endif
diff --git a/api/PluggableUSB.cpp b/api/PluggableUSB.cpp
@@ -20,6 +20,8 @@
 #include "USBAPI.h"
 #include "PluggableUSB.h"
 
+using namespace arduino;
+
 int PluggableUSB_::getInterface(uint8_t* interfaceCount)
 {
 	int sent = 0;
diff --git a/api/PluggableUSB.h b/api/PluggableUSB.h
@@ -24,6 +24,8 @@
 #include <stdint.h>
 #include <stddef.h>
 
+namespace arduino {
+
 // core need to define
 void* epBuffer(unsigned int n); // -> returns a poointer to the Nth element of the EP buffer structure
 
@@ -72,4 +74,6 @@ class PluggableUSB_ {
 // https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use
 PluggableUSB_& PluggableUSB();
 
+}
+
 #endif
diff --git a/api/Print.cpp b/api/Print.cpp
@@ -23,6 +23,8 @@
 
 #include "Print.h"
 
+using namespace arduino;
+
 // Public Methods //////////////////////////////////////////////////////////////
 
 /* default implementation: may be overridden */
diff --git a/api/Print.h b/api/Print.h
@@ -29,6 +29,8 @@
 #define OCT 8
 #define BIN 2
 
+namespace arduino {
+
 class Print
 {
   private:
@@ -90,3 +92,4 @@ class Print
     virtual void flush() { /* Empty implementation for backward compatibility */ }
 };
 
+}
diff --git a/api/Printable.h b/api/Printable.h
@@ -20,6 +20,8 @@
 
 #include <stdlib.h>
 
+namespace arduino {
+
 class Print;
 
 /** The Printable class provides a way for new classes to allow themselves to be printed.
@@ -34,3 +36,4 @@ class Printable
     virtual size_t printTo(Print& p) const = 0;
 };
 
+}
diff --git a/api/RingBuffer.h b/api/RingBuffer.h
@@ -23,6 +23,8 @@
 
 #include <stdint.h>
 
+namespace arduino {
+
 // Define constants and variables for buffering incoming serial data.  We're
 // using a ring buffer (I think), in which head is the index of the location
 // to which to write the next incoming character and tail is the index of the
@@ -137,6 +139,7 @@ bool RingBufferN<N>::isFull()
   return (nextIndex(_iHead) == _iTail);
 }
 
-#endif /* _RING_BUFFER_ */
+}
 
+#endif /* _RING_BUFFER_ */
 #endif /* __cplusplus */
diff --git a/api/Server.h b/api/Server.h
@@ -21,8 +21,11 @@
 
 #include "Print.h"
 
+namespace arduino {
+
 class Server : public Print {
   public:
     virtual void begin() = 0;
 };
 
+}
diff --git a/api/Stream.cpp b/api/Stream.cpp
@@ -27,6 +27,8 @@
 
 #define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
 
+using namespace arduino;
+
 // private method to read stream with timeout
 int Stream::timedRead()
 {
diff --git a/api/Stream.h b/api/Stream.h
@@ -34,6 +34,8 @@
 readBytesBetween( pre_string, terminator, buffer, length)
 */
 
+namespace arduino {
+
 // This enumeration provides the lookahead options for parseInt(), parseFloat()
 // The rules set out here are used until either the first valid character is found
 // or a time out occurs due to lack of input.
@@ -125,3 +127,5 @@ class Stream : public Print
 };
 
 #undef NO_IGNORE_CHAR
+
+}
diff --git a/api/String.cpp b/api/String.cpp
@@ -27,6 +27,8 @@
 /*  Constructors                             */
 /*********************************************/
 
+using namespace arduino;
+
 String::String(const char *cstr)
 {
 	init();
@@ -352,77 +354,77 @@ unsigned char String::concat(const __FlashStringHelper * str)
 /*  Concatenate                              */
 /*********************************************/
 
-StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, const String &rhs)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(rhs.buffer, rhs.len)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, const char *cstr)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, char c)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(c)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, unsigned char num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, int num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, unsigned int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, long num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, unsigned long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, float num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, float num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, double num)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, double num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
+StringSumHelper & arduino::operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
 	if (!a.concat(rhs))	a.invalidate();
diff --git a/api/String.h b/api/String.h
@@ -19,10 +19,11 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#pragma once
-
 #ifdef __cplusplus
 
+#ifndef __ARDUINO_STRINGS__
+#define __ARDUINO_STRINGS__
+
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ -32,6 +33,7 @@
 #include "deprecated-avr-comp/avr/pgmspace.h"
 #endif
 
+namespace arduino {
 // When compiling programs with this class, the following gcc parameters
 // dramatically increase performance and memory (RAM) efficiency, typically
 // with little or no increase in code size.
@@ -48,6 +50,7 @@ class StringSumHelper;
 // The string class
 class String
 {
+	friend class StringSumHelper;
 	// use a function pointer to allow for "if (s)" without the
 	// complications of an operator bool(). for more information, see:
 	// http://www.artima.com/cppsource/safebool.html
@@ -231,16 +234,18 @@ class String
 class StringSumHelper : public String
 {
 public:
-	StringSumHelper(const String &s) : String(s) {}
-	StringSumHelper(const char *p) : String(p) {}
-	StringSumHelper(char c) : String(c) {}
-	StringSumHelper(unsigned char num) : String(num) {}
-	StringSumHelper(int num) : String(num) {}
-	StringSumHelper(unsigned int num) : String(num) {}
-	StringSumHelper(long num) : String(num) {}
-	StringSumHelper(unsigned long num) : String(num) {}
-	StringSumHelper(float num) : String(num) {}
-	StringSumHelper(double num) : String(num) {}
+    StringSumHelper(const String &s) : String(s) {}
+    StringSumHelper(const char *p) : String(p) {}
+    StringSumHelper(char c) : String(c) {}
+    StringSumHelper(unsigned char num) : String(num) {}
+    StringSumHelper(int num) : String(num) {}
+    StringSumHelper(unsigned int num) : String(num) {}
+    StringSumHelper(long num) : String(num) {}
+    StringSumHelper(unsigned long num) : String(num) {}
+    StringSumHelper(float num) : String(num) {}
+    StringSumHelper(double num) : String(num) {}
 };
 
+}
 #endif  // __cplusplus
+#endif  // __ARDUINO_STRINGS__
diff --git a/api/USBAPI.h b/api/USBAPI.h
@@ -22,6 +22,7 @@
 
 #include <stdint.h>
 
+namespace arduino {
 //================================================================================
 //================================================================================
 //  Low level API
@@ -57,4 +58,5 @@ int USB_Recv(uint8_t ep, void* data, int len);		// non-blocking
 int USB_Recv(uint8_t ep);							// non-blocking
 void USB_Flush(uint8_t ep);
 
+}
 #endif
diff --git a/api/Udp.h b/api/Udp.h
@@ -37,6 +37,8 @@
 #include "Stream.h"
 #include "IPAddress.h"
 
+namespace arduino {
+
 class UDP : public Stream {
 
 public:
@@ -84,3 +86,4 @@ class UDP : public Stream {
   uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
 };
 
+}
diff --git a/api/WCharacter.h b/api/WCharacter.h

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@`
`20`	`20`	`#include "IPAddress.h"`
`21`	`21`	`#include "Print.h"`
`22`	`22`
	`23`	`+using namespace arduino;`
	`24`	`+`
`23`	`25`	`IPAddress::IPAddress()`
`24`	`26`	`{`
`25`	`27`	`_address.dword = 0;`