andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 07:49:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

formatting

Browse Source
This commit is contained in:
Proddy
2023-01-12 17:41:24 +01:00
parent e3f51b34b5
commit 7841b44b43
4 changed files with 184 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
lib_standalone/Arduino.h
View File

@@ -90,10 +90,9 @@ int vsnprintf_P(char * str, size_t size, const char * format, va_list ap);
class Print;
class NativeConsole: public Stream {
public:
class NativeConsole : public Stream {
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;
};

85
lib_standalone/Print.h
View File

@@ -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; };
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 };
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(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() { };
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:
private:
int err_{0};
};

11
lib_standalone/Printable.h
View File

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

70
lib_standalone/Stream.h
View File

@@ -36,60 +36,55 @@
readBytesBetween( pre_string, terminator, buffer, length)
*/
class Stream: public Print
{
protected:
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
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(uint8_t *target)
{
return find((char *) target);
bool find(const char * target); // reads data from the stream until the target string is found
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)
{
return find((char *) target, length);
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) {
return find((char *)target, length);
}
// returns true if target string is found, false if timed out
bool find(char target)
{
return find (&target, 1);
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)
{
return findUntil((char *) target, terminator);
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) {
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)
{
return findUntil((char *) target, targetLen, terminate, termLen);
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) {
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)
{
return readBytes((char *) buffer, 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)
// 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)
{
return readBytesUntil(terminator, (char *) buffer, 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
// 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