Stream Class Reference

#include <Stream.h>

Inheritance diagram for Stream:

Collaboration diagram for Stream:

Classes
struct	MultiTarget

Public Member Functions
virtual int	available ()=0
virtual int	read ()=0
virtual int	peek ()=0
virtual void	flush ()=0
	Stream ()
void	setTimeout (unsigned long timeout)
unsigned long	getTimeout (void)
bool	find (const char *target)
bool	find (const uint8_t *target)
bool	find (const char *target, size_t length)
bool	find (const uint8_t *target, size_t length)
bool	find (char target)
bool	findUntil (const char *target, const char *terminator)
bool	findUntil (const uint8_t *target, const char *terminator)
bool	findUntil (const char *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)
long	parseInt (LookaheadMode lookahead=SKIP_ALL, char ignore=NO_IGNORE_CHAR)
float	parseFloat (LookaheadMode lookahead=SKIP_ALL, char ignore=NO_IGNORE_CHAR)
virtual size_t	readBytes (char *buffer, size_t length)
size_t	readBytes (uint8_t *buffer, size_t length)
virtual size_t	readBytesUntil (char terminator, char *buffer, size_t length)
size_t	readBytesUntil (char terminator, uint8_t *buffer, size_t length)
String	readString ()
String	readStringUntil (char terminator)
Public Member Functions inherited from Print
	Print ()
int	getWriteError ()
void	clearWriteError ()
virtual size_t	write (uint8_t)=0
size_t	write (const char *str)
virtual size_t	write (const uint8_t *buffer, size_t size)
size_t	write (const char *buffer, size_t size)
size_t	print (const __FlashStringHelper *)
size_t	print (const String &)
size_t	print (const char[])
size_t	print (char)
size_t	print (unsigned char, int=DEC)
size_t	print (int, int=DEC)
size_t	print (unsigned int, int=DEC)
size_t	print (long, int=DEC)
size_t	print (unsigned long, int=DEC)
size_t	print (double, int=2)
size_t	print (const Printable &)
size_t	println (const __FlashStringHelper *)
size_t	println (const String &s)
size_t	println (const char[])
size_t	println (char)
size_t	println (unsigned char, int=DEC)
size_t	println (int, int=DEC)
size_t	println (unsigned int, int=DEC)
size_t	println (long, int=DEC)
size_t	println (unsigned long, int=DEC)
size_t	println (double, int=2)
size_t	println (const Printable &)
size_t	println (void)
void	println (int64_t, uint8_t=DEC)
void	print (int64_t, uint8_t=DEC)
void	println (uint64_t, uint8_t=DEC)
void	print (uint64_t, uint8_t=DEC)

Protected Member Functions
int	timedRead ()
int	timedPeek ()
int	peekNextDigit (LookaheadMode lookahead, bool detectDecimal)
long	parseInt (char ignore)
float	parseFloat (char ignore)
int	findMulti (struct MultiTarget *targets, int tCount)
Protected Member Functions inherited from Print
void	setWriteError (int err=1)

Protected Attributes
unsigned long	_timeout
unsigned long	_startMillis

Constructor & Destructor Documentation

Stream()

Stream::Stream

(

)

             {
        _timeout = 1000;
    }

Member Function Documentation

timedRead()

int Stream::timedRead ( )

protected

                      {
    int c;
    _startMillis = millis();
    do {
        c = read();
        if (c >= 0) {
            return c;
        }
    } while (millis() - _startMillis < _timeout);
    return -1; // -1 indicates timeout
}

Here is the call graph for this function:

Here is the caller graph for this function:

timedPeek()

int Stream::timedPeek ( )

protected

                      {
    int c;
    _startMillis = millis();
    do {
        c = peek();
        if (c >= 0) {
            return c;
        }
    } while (millis() - _startMillis < _timeout);
    return -1; // -1 indicates timeout
}

Here is the call graph for this function:

Here is the caller graph for this function:

peekNextDigit()

int Stream::peekNextDigit ( LookaheadMode  lookahead, bool  detectDecimal  )

protected

                                                                     {
    int c;
    while (1) {
        c = timedPeek();
 
        if (c < 0 || c == '-' || (c >= '0' && c <= '9') || (detectDecimal && c == '.')) {
            return c;
        }
 
        switch (lookahead) {
        case SKIP_NONE:
            return -1; // Fail code.
        case SKIP_WHITESPACE:
            switch (c) {
            case ' ':
            case '\t':
            case '\r':
            case '\n':
                break;
            default:
                return -1; // Fail code.
            }
        case SKIP_ALL:
            break;
        }
        read(); // discard non-numeric
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

available()

virtual int Stream::available ( )

pure virtual

Implemented in TwoWire, HardwareSerial, USBSerial, and WebSocketSerial.

read()

virtual int Stream::read ( )

pure virtual

Implemented in TwoWire, HardwareSerial, USBSerial, and WebSocketSerial.

Here is the caller graph for this function:

peek()

virtual int Stream::peek ( )

pure virtual

Implemented in TwoWire, HardwareSerial, USBSerial, and WebSocketSerial.

Here is the caller graph for this function:

flush()

virtual void Stream::flush ( )

pure virtual

Implemented in TwoWire, USBSerial, HardwareSerial, and WebSocketSerial.

setTimeout()

void Stream::setTimeout

(

unsigned long

timeout

)

{
    _timeout = timeout;
}

getTimeout()

unsigned long Stream::getTimeout

(

void

)

                                   {
        return _timeout;
    }

find() [1/5]

bool Stream::find

(

const char *

target

)

                                    {
    return findUntil(target, strlen(target), NULL, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find() [2/5]

bool Stream::find

(

const uint8_t *

target

)

                                     {
        return find((const char *)target);
    }

Here is the call graph for this function:

find() [3/5]

bool Stream::find	(	const char *	target,
		size_t	length
	)

                                                   {
    return findUntil(target, length, NULL, 0);
}

Here is the call graph for this function:

find() [4/5]

bool Stream::find	(	const uint8_t *	target,
		size_t	length
	)

                                                    {
        return find((const char *)target, length);
    }

Here is the call graph for this function:

find() [5/5]

bool Stream::find

(

char

target

)

                           {
        return find(&target, 1);
    }

Here is the call graph for this function:

findUntil() [1/4]

bool Stream::findUntil	(	const char *	target,
		const char *	terminator
	)

                                                                 {
    return findUntil(target, strlen(target), terminator, strlen(terminator));
}

Here is the caller graph for this function:

findUntil() [2/4]

bool Stream::findUntil	(	const uint8_t *	target,
		const char *	terminator
	)

                                                                  {
        return findUntil((const char *)target, terminator);
    }

Here is the call graph for this function:

findUntil() [3/4]

bool Stream::findUntil	(	const char *	target,
		size_t	targetLen,
		const char *	terminate,
		size_t	termLen
	)

                                                                                                   {
    if (terminator == NULL) {
        MultiTarget t[1] = { { target, targetLen, 0 } };
        return findMulti(t, 1) == 0 ? true : false;
    } else {
        MultiTarget t[2] = { { target, targetLen, 0 }, { terminator, termLen, 0 } };
        return findMulti(t, 2) == 0 ? true : false;
    }
}

Here is the call graph for this function:

findUntil() [4/4]

bool Stream::findUntil	(	const uint8_t *	target,
		size_t	targetLen,
		const char *	terminate,
		size_t	termLen
	)

                                                                                                   {
        return findUntil((const char *)target, targetLen, terminate, termLen);
    }

Here is the call graph for this function:

parseInt() [1/2]

long Stream::parseInt	(	LookaheadMode	lookahead = SKIP_ALL,
		char	ignore = NO_IGNORE_CHAR
	)

                                                          {
    bool isNegative = false;
    long value = 0;
    int c;
 
    c = peekNextDigit(lookahead, false);
    // ignore non numeric leading characters
    if (c < 0) {
        return 0; // zero returned if timeout
    }
 
    do {
        if (c == ignore)
            ; // 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 == ignore);
 
    if (isNegative) {
        value = -value;
    }
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseFloat() [1/2]

float Stream::parseFloat	(	LookaheadMode	lookahead = SKIP_ALL,
		char	ignore = NO_IGNORE_CHAR
	)

                                                             {
    bool isNegative = false;
    bool isFraction = false;
    long value = 0;
    int c;
    float fraction = 1.0;
 
    c = peekNextDigit(lookahead, true);
    // ignore non numeric leading characters
    if (c < 0) {
        return 0; // zero returned if timeout
    }
 
    do {
        if (c == ignore)
            ; // 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.1;
            }
        }
        read(); // consume the character we got with peek
        c = timedPeek();
    } while ((c >= '0' && c <= '9') || (c == '.' && !isFraction) || c == ignore);
 
    if (isNegative) {
        value = -value;
    }
    if (isFraction) {
        return value * fraction;
    } else {
        return value;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

readBytes() [1/2]

size_t Stream::readBytes ( char *  buffer, size_t  length  )

virtual

Reimplemented in USBSerial.

                                                    {
    size_t count = 0;
    while (count < length) {
        int c = timedRead();
        if (c < 0) {
            break;
        }
        *buffer++ = (char)c;
        count++;
    }
    return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

readBytes() [2/2]

size_t Stream::readBytes	(	uint8_t *	buffer,
		size_t	length
	)

                                                     {
        return readBytes((char *)buffer, length);
    }

Here is the call graph for this function:

readBytesUntil() [1/2]

size_t Stream::readBytesUntil ( char  terminator, char *  buffer, size_t  length  )

virtual

Reimplemented in USBSerial.

                                                                          {
    if (length < 1) {
        return 0;
    }
    size_t index = 0;
    while (index < length) {
        int c = timedRead();
        if (c < 0 || c == terminator) {
            break;
        }
        *buffer++ = (char)c;
        index++;
    }
    return index; // return number of characters, not including null terminator
}

Here is the call graph for this function:

Here is the caller graph for this function:

readBytesUntil() [2/2]

size_t Stream::readBytesUntil	(	char	terminator,
		uint8_t *	buffer,
		size_t	length
	)

                                                                           {
        return readBytesUntil(terminator, (char *)buffer, length);
    }

Here is the call graph for this function:

readString()

String Stream::readString

(

)

                          {
    String ret;
    int c = timedRead();
    while (c >= 0) {
        ret += (char)c;
        c = timedRead();
    }
    return ret;
}

Here is the call graph for this function:

readStringUntil()

String Stream::readStringUntil

(

char

terminator

)

                                              {
    String ret;
    int c = timedRead();
    while (c >= 0 && c != terminator) {
        ret += (char)c;
        c = timedRead();
    }
    return ret;
}

Here is the call graph for this function:

parseInt() [2/2]

long Stream::parseInt ( char  ignore )

protected

                               {
        return parseInt(SKIP_ALL, ignore);
    }

Here is the call graph for this function:

parseFloat() [2/2]

float Stream::parseFloat ( char  ignore )

protected

                                  {
        return parseFloat(SKIP_ALL, ignore);
    }

Here is the call graph for this function:

findMulti()

int Stream::findMulti ( struct MultiTarget *  targets, int  tCount  )

protected

                                                                   {
    // any zero length target string automatically matches and would make
    // a mess of the rest of the algorithm.
    for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
        if (t->len <= 0) {
            return t - targets;
        }
    }
 
    while (1) {
        int c = timedRead();
        if (c < 0) {
            return -1;
        }
 
        for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
            // the simple case is if we match, deal with that first.
            if (c == t->str[t->index]) {
                if (++t->index == t->len) {
                    return t - targets;
                } else {
                    continue;
                }
            }
 
            // if not we need to walk back and see if we could have matched further
            // down the stream (ie '1112' doesn't match the first position in '11112'
            // but it will match the second position so we can't just reset the current
            // index to 0 when we find a mismatch.
            if (t->index == 0) {
                continue;
            }
 
            int origIndex = t->index;
            do {
                --t->index;
                // first check if current char works against the new current index
                if (c != t->str[t->index]) {
                    continue;
                }
 
                // if it's the only char then we're good, nothing more to check
                if (t->index == 0) {
                    t->index++;
                    break;
                }
 
                // otherwise we need to check the rest of the found string
                int diff = origIndex - t->index;
                size_t i;
                for (i = 0; i < t->index; ++i) {
                    if (t->str[i] != t->str[i + diff]) {
                        break;
                    }
                }
 
                // if we successfully got through the previous loop then our current
                // index is good.
                if (i == t->index) {
                    t->index++;
                    break;
                }
 
                // otherwise we just try the next index
            } while (t->index);
        }
    }
    // unreachable
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_timeout

unsigned long Stream::_timeout

protected

_startMillis

unsigned long Stream::_startMillis

protected