Stream.h

Go to the documentation of this file.

 
#ifndef Stream_h
#define Stream_h
 
#include <inttypes.h>
#include "Print.h"
 
 
#define NO_SKIP_CHAR  1  // a magic char not found in a valid ASCII numeric field
#ifndef YIELD
#define YIELD
#endif
 
#define F(x) (x)
 
class Stream: public Print {
    protected:
        unsigned long _timeout = 1000;
 
        unsigned long _startMillis;
 
        int timedRead();
 
        int timedPeek();
 
        int peekNextDigit(); //
 
    public:
        virtual int available() = 0;
 
        virtual int read() = 0;
 
        virtual int peek() = 0;
 
        Stream() {}
 
        //Input operators - they are experimental and can be buggy
        Stream &operator >>(char& c);
 
        Stream &operator >>(char* buffer);
 
        Stream &operator >>(uint8_t* buffer);
 
        //Integer types
        __INTEGER_ONLY__(T, Stream&) operator >>(T& val){
            val = parseNum<T>();
            return *this;
        }
        //Floating point types
        __FLOATING_ONLY__(T, Stream&) operator >>(T& val){
            val = parseNum<T>();
            return *this;
        }
 
// parsing methods
 
        void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
 
        virtual void width(size_t width_);
 
        bool find(const char *target);
 
        bool find(uint8_t *target) {
            return find((char *) target);
        }
 
        bool find(const char *target, size_t length);
 
        bool find(const uint8_t *target, size_t length) {
            return find((char *) target, length);
        }
 
        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, 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 inline parseInt(){
            return parseInt(NO_SKIP_CHAR); // terminate on first non-digit character (or timeout)
        }
 
        __INTEGER_ONLY__(T,T) inline parseNum(){
            return parseNum<T>(NO_SKIP_CHAR);
        }
 
        float inline parseFloat(){// float version of parseInt
            return parseNum<float>(NO_SKIP_CHAR);
        }
 
        __FLOATING_ONLY__(T,T) inline parseNum(){
            return parseNum<T>(NO_SKIP_CHAR);
        }
 
        virtual size_t readBytes(char *buffer, size_t length);
 
        virtual size_t readBytes(uint8_t *buffer, size_t length) {
            return readBytes((char *) buffer, length);
        }
 
        size_t readBytesUntil(char terminator, char *buffer, size_t length); // as readBytes with terminator character
 
        size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length) {
            return readBytesUntil(terminator, (char *) buffer, length);
        }
        // Arduino String functions to be added here
#ifdef String_class_h
 
        virtual String readString();
 
        String readStringUntil(char terminator);
#endif
 
    protected:
        long inline parseInt(char skipChar){
            return parseNum<long>(skipChar);
        }
 
        __INTEGER_ONLY__(T,T) parseNum(char skipChar){
            bool isNegative = false;
            T value = 0;
            int c;
 
            c = peekNextDigit();
            // ignore non numeric leading characters
            if(c < 0)
                return 0; // zero returned if timeout
 
            do {
                if(c == skipChar)
                    ; // ignore this character
                else if(c == '-')
                    isNegative = true;
                else if(c >= '0' && c <= '9')        // is c a digit?
                    value = value * 10 + c - '0';
                read();  // consume the character we got with peek
                c = timedPeek();
            } while((c >= '0' && c <= '9') || c == skipChar);
 
            if(isNegative)
                value = -value;
            return value;
        }
 
        float inline parseFloat(char skipChar){ // as above but the given skipChar is ignored
            return parseFloat(NO_SKIP_CHAR);
        }
 
        __FLOATING_ONLY__(T,T) parseNum(char skipChar){
            bool isNegative = false;
            bool isFraction = false;
            long value = 0;
            int c;
            T fraction = 1.0f;
 
            c = peekNextDigit();
            // ignore non numeric leading characters
            if(c < 0)
                return 0; // zero returned if timeout
 
            do {
                if(c == skipChar)
                    ; // ignore
                else if(c == '-')
                    isNegative = true;
                else if(c == '.')
                    isFraction = true;
                else if(c >= '0' && c <= '9') {      // is c a digit?
                    value = value * 10 + c - '0';
                    if(isFraction)
                        fraction *= 0.1f;
                }
                read();  // consume the character we got with peek
                c = timedPeek();
            } while((c >= '0' && c <= '9') || c == '.' || c == skipChar);
 
            if(isNegative)
                value = -value;
            if(isFraction)
                return value * fraction;
            else
                return value;
        }
 
        virtual size_t widthCheck(size_t width_);
 
        size_t _width = INT32_MAX;
};
 
#endif