formatting

lib_standalone/Arduino.h

@@ -90,10 +90,9 @@ int vsnprintf_P(char * str, size_t size, const char * format, va_list ap);
 
 class Print;
 
-class NativeConsole: public Stream {
+class NativeConsole : public Stream {
-public:
+  public:
     void begin(unsigned long baud __attribute__((unused))) {
-
     }
 
     int available() override {
@@ -154,7 +153,7 @@ public:
         }
     }
 
-	size_t write(const uint8_t *buffer, size_t size) {
+    size_t write(const uint8_t * buffer, size_t size) {
         if (::write(STDOUT_FILENO, buffer, size) == (ssize_t)size) {
             return size;
         } else {
@@ -162,7 +161,7 @@ public:
         }
     }
 
-private:
+  private:
     int peek_ = -1;
 };
 

lib_standalone/Print.h

@@ -30,24 +30,49 @@
 #include <Printable.h>
 #include <WString.h>
 
-int vsnprintf_P(char *str, size_t size, const char *format, va_list ap);
+int vsnprintf_P(char * str, size_t size, const char * format, va_list ap);
 
 class Print {
-public:
+  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; };
+    virtual size_t write(const uint8_t * buffer, size_t size) {
-	void setWriteError(int err = 1) { err_ = err; }
+        for (size_t i = 0; i < size; i++) {
-	int getWriteError() { return err_; }
+            write(*buffer);
-	void clearWriteError() {}
+            buffer++;
-	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)); }
+        return size;
-	size_t print(const Printable &printable) { return printable.printTo(*this); }
+    };
-	size_t print(int value) { return print(std::to_string(value).c_str()); }
+    void setWriteError(int err = 1) {
-	size_t print(unsigned int value) { return print(std::to_string(value).c_str()); }
+        err_ = err;
-	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()); }
+    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 };
+        char    str[4096] = {0};
         va_list ap;
 
         va_start(ap, format);
@@ -59,16 +84,30 @@ public:
 
         return print(str);
     }
-	size_t println() { return print("\r\n"); }
+    size_t println() {
-	size_t println(const char *data) { return print(data) + println(); }
+        return print("\r\n");
-	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(const char * data) {
-	size_t println(unsigned int value) { return print(std::to_string(value).c_str()) + println(); }
+        return print(data) + 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(const Printable & printable) {
-	virtual void flush() { };
+        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:
+  private:
     int err_{0};
 };
 

lib_standalone/Printable.h

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

lib_standalone/Stream.h

@@ -36,60 +36,55 @@
  readBytesBetween( pre_string, terminator, buffer, length)
  */
 
-class Stream: public Print
+class Stream : public Print {
-{
+  protected:
-protected:
     unsigned long _timeout;        // number of milliseconds to wait for the next char before aborting timed read
     unsigned long _startMillis;    // used for timeout measurement
     int           timedRead();     // private method to read stream with timeout
     int           timedPeek();     // private method to peek stream with timeout
     int           peekNextDigit(); // returns the next numeric digit in the stream or -1 if timeout
 
-public:
+  public:
     virtual int available() = 0;
     virtual int read()      = 0;
     virtual int peek()      = 0;
 
-    Stream():_startMillis(0)
+    Stream()
-    {
+        : _startMillis(0) {
         _timeout = 1000;
     }
-    virtual ~Stream() {}
+    virtual ~Stream() {
+    }
 
-// parsing methods
+    // parsing methods
 
     void          setTimeout(unsigned long timeout); // sets maximum milliseconds to wait for stream data, default is 1 second
     unsigned long getTimeout(void);
 
-    bool find(const char *target);   // reads data from the stream until the target string is found
+    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);
-        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 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);
-        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);
-        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 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);
-        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 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);
-        return findUntil((char *) target, targetLen, terminate, termLen);
     }
 
     long parseInt(); // returns the first valid (long) integer value from the current position.
@@ -98,7 +93,7 @@ public:
 
     float parseFloat(); // float version of parseInt
 
-    virtual size_t readBytes(char *buffer, size_t length) // read chars from stream into buffer
+    virtual size_t readBytes(char * buffer, size_t length) // read chars from stream into buffer
     {
         size_t total = 0;
 
@@ -113,14 +108,13 @@ 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);
-        return readBytes((char *) buffer, length);
     }
     // terminates if length characters have been read or timeout (see setTimeout)
     // returns the number of characters placed in the buffer (0 means no valid data found)
 
-    size_t readBytesUntil(char terminator, char *buffer, size_t length) // as readBytes with terminator character
+    size_t readBytesUntil(char terminator, char * buffer, size_t length) // as readBytes with terminator character
     {
         size_t total = 0;
 
@@ -135,9 +129,8 @@ 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);
-        return readBytesUntil(terminator, (char *) buffer, length);
     }
     // terminates if length characters have been read, timeout, or if the terminator character  detected
     // returns the number of characters placed in the buffer (0 means no valid data found)
@@ -175,7 +168,7 @@ public:
     }
 #endif
 
-protected:
+  protected:
     long parseInt(char skipChar); // as above but the given skipChar is ignored
     // as above but the given skipChar is ignored
     // this allows format characters (typically commas) in values to be ignored
@@ -183,15 +176,14 @@ protected:
     float parseFloat(char skipChar); // as above but the given skipChar is ignored
 
     struct MultiTarget {
-      const char *str;  // string you're searching for
+        const char * str;   // string you're searching for
         size_t       len;   // length of string you're searching for
         size_t       index; // index used by the search routine.
     };
 
     // 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);
+    int findMulti(struct MultiTarget * targets, int tCount);
-
 };
 
 #endif