formatting

lib_standalone/Arduino.h

@@ -93,7 +93,6 @@ class Print;
 class NativeConsole : public Stream {
   public:
     void begin(unsigned long baud __attribute__((unused))) {
-
     }
 
     int available() override {

lib_standalone/Print.h

@@ -35,17 +35,42 @@ int vsnprintf_P(char *str, size_t size, const char *format, va_list ap);
 class Print {
   public:
     virtual size_t write(uint8_t c) = 0;
-	virtual size_t write(const uint8_t *buffer, size_t size) { for (size_t i = 0; i < size; i++) { write(*buffer); buffer++; }; return size; };
-	void setWriteError(int err = 1) { err_ = err; }
-	int getWriteError() { return err_; }
-	void clearWriteError() {}
-	size_t print(char c) { return write((uint8_t)c); }
-	size_t print(const char *data) { return write(reinterpret_cast<const uint8_t *>(data), strlen(data)); }
-	size_t print(const Printable &printable) { return printable.printTo(*this); }
-	size_t print(int value) { return print(std::to_string(value).c_str()); }
-	size_t print(unsigned int value) { return print(std::to_string(value).c_str()); }
-	size_t print(long value) { return print(std::to_string(value).c_str()); }
-	size_t print(unsigned long value) { return print(std::to_string(value).c_str()); }
+    virtual size_t write(const uint8_t * buffer, size_t size) {
+        for (size_t i = 0; i < size; i++) {
+            write(*buffer);
+            buffer++;
+        };
+        return size;
+    };
+    void setWriteError(int err = 1) {
+        err_ = err;
+    }
+    int getWriteError() {
+        return err_;
+    }
+    void clearWriteError() {
+    }
+    size_t print(char c) {
+        return write((uint8_t)c);
+    }
+    size_t print(const char * data) {
+        return write(reinterpret_cast<const uint8_t *>(data), strlen(data));
+    }
+    size_t print(const Printable & printable) {
+        return printable.printTo(*this);
+    }
+    size_t print(int value) {
+        return print(std::to_string(value).c_str());
+    }
+    size_t print(unsigned int value) {
+        return print(std::to_string(value).c_str());
+    }
+    size_t print(long value) {
+        return print(std::to_string(value).c_str());
+    }
+    size_t print(unsigned long value) {
+        return print(std::to_string(value).c_str());
+    }
     size_t printf(const char * format, ...) {
         char    str[4096] = {0};
         va_list ap;
@@ -59,13 +84,27 @@ public:
 
         return print(str);
     }
-	size_t println() { return print("\r\n"); }
-	size_t println(const char *data) { return print(data) + println(); }
-	size_t println(const Printable &printable) { return printable.printTo(*this) + println(); }
-	size_t println(int value) { return print(std::to_string(value).c_str()) + println(); }
-	size_t println(unsigned int value) { return print(std::to_string(value).c_str()) + println(); }
-	size_t println(long value) { return print(std::to_string(value).c_str()) + println(); }
-	size_t println(unsigned long value) { return print(std::to_string(value).c_str()) + println(); }
+    size_t println() {
+        return print("\r\n");
+    }
+    size_t println(const char * data) {
+        return print(data) + println();
+    }
+    size_t println(const Printable & printable) {
+        return printable.printTo(*this) + println();
+    }
+    size_t println(int value) {
+        return print(std::to_string(value).c_str()) + println();
+    }
+    size_t println(unsigned int value) {
+        return print(std::to_string(value).c_str()) + println();
+    }
+    size_t println(long value) {
+        return print(std::to_string(value).c_str()) + println();
+    }
+    size_t println(unsigned long value) {
+        return print(std::to_string(value).c_str()) + println();
+    }
     virtual void flush(){};
 
   private:

lib_standalone/Printable.h

@@ -30,12 +30,11 @@ class Print;
  Print::print and Print::println methods.
  */
 
-class Printable
-{
+class Printable {
   public:
-    virtual ~Printable() {}
+    virtual ~Printable() {
+    }
     virtual size_t printTo(Print & p) const = 0;
 };
 
 #endif
-

lib_standalone/Stream.h

@@ -36,8 +36,7 @@
  readBytesBetween( pre_string, terminator, buffer, length)
  */
 
-class Stream: public Print
-{
+class Stream : public Print {
   protected:
     unsigned long _timeout;        // number of milliseconds to wait for the next char before aborting timed read
     unsigned long _startMillis;    // used for timeout measurement
@@ -50,11 +49,12 @@ public:
     virtual int read()      = 0;
     virtual int peek()      = 0;
 
-    Stream():_startMillis(0)
-    {
+    Stream()
+        : _startMillis(0) {
         _timeout = 1000;
     }
-    virtual ~Stream() {}
+    virtual ~Stream() {
+    }
 
     // parsing methods
 
@@ -62,33 +62,28 @@ public:
     unsigned long getTimeout(void);
 
     bool find(const char * target); // reads data from the stream until the target string is found
-    bool find(uint8_t *target)
-    {
+    bool find(uint8_t * target) {
         return find((char *)target);
     }
     // returns true if target string is found, false if timed out (see setTimeout)
 
     bool find(const char * target, size_t length); // reads data from the stream until the target string of given length is found
-    bool find(const uint8_t *target, size_t length)
-    {
+    bool find(const uint8_t * target, size_t length) {
         return find((char *)target, length);
     }
     // returns true if target string is found, false if timed out
 
-    bool find(char target)
-    {
+    bool find(char target) {
         return find(&target, 1);
     }
 
     bool findUntil(const char * target, const char * terminator); // as find but search ends if the terminator string is found
-    bool findUntil(const uint8_t *target, const char *terminator)
-    {
+    bool findUntil(const uint8_t * target, const char * terminator) {
         return findUntil((char *)target, terminator);
     }
 
     bool findUntil(const char * target, size_t targetLen, const char * terminate, size_t termLen); // as above but search ends if the terminate string is found
-    bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen)
-    {
+    bool findUntil(const uint8_t * target, size_t targetLen, const char * terminate, size_t termLen) {
         return findUntil((char *)target, targetLen, terminate, termLen);
     }
 
@@ -113,8 +108,7 @@ public:
 
         return total;
     }
-    virtual size_t readBytes(uint8_t *buffer, size_t length)
-    {
+    virtual size_t readBytes(uint8_t * buffer, size_t length) {
         return readBytes((char *)buffer, length);
     }
     // terminates if length characters have been read or timeout (see setTimeout)
@@ -135,8 +129,7 @@ public:
 
         return total;
     }
-    size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length)
-    {
+    size_t readBytesUntil(char terminator, uint8_t * buffer, size_t length) {
         return readBytesUntil(terminator, (char *)buffer, length);
     }
     // terminates if length characters have been read, timeout, or if the terminator character  detected
@@ -191,7 +184,6 @@ protected:
     // This allows you to search for an arbitrary number of strings.
     // Returns index of the target that is found first or -1 if timeout occurs.
     int findMulti(struct MultiTarget * targets, int tCount);
-
 };
 
 #endif