Reader.h

Go to the documentation of this file.

/*
    Reader.cpp - a base class for reading data
    For AVR ATMega328p (Arduino Uno) and ATMega2560 (Arduino Mega).
    This is part of the AVRTools library.
    Copyright (c) 2014 Igor Mikolic-Torreira.  All right reserved.
    Functions readLong() and readFloat() adapted from Arduino code that
    is Copyright (c) 2008 David A. Mellis and licensed under LGPL.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef Reader_h
#define Reader_h
 
 
#include <stddef.h>
#include <stdint.h>
 
 
#ifndef SERIAL_INPUT_EOL
#define SERIAL_INPUT_EOL    '\n'
#endif
 
 
class Reader
{
 
public:
 
 
    Reader();
 
 
 
    // Virtual methods (pure -- need to be implmented by derived classes)
 
    virtual int read() = 0;
 
 
    virtual int peek() = 0;
 
 
    virtual bool available() = 0;
 
 
 
 
    // Parsing methods
 
    void setTimeout( unsigned long milliseconds )
    { mTimeOut = milliseconds; }
 
 
    bool find( const char *target )
    { return findUntil( target, 0 ); }
 
 
    bool find( const char *target, size_t length )
    { return findUntil( target, length, NULL, 0 ); }
 
 
    bool findUntil( const char *target, const char *terminator );
 
 
    bool findUntil( const char *target, size_t targetLen, const char *terminate, size_t termLen );
 
 
    bool readLong( long* result );
 
 
    bool readFloat( float* result );
 
 
    bool readLong( long* result, char skipChar );
 
 
    bool readFloat( float* result, char skipChar );
 
 
    size_t readBytes( char *buffer, size_t length );
 
 
   size_t readBytesUntil( char terminator, char* buffer, size_t length );
 
 
    size_t readBytes( uint8_t* buffer, size_t length )
    { return readBytes( reinterpret_cast<char*>(buffer), length ); }
 
 
 
   size_t readBytesUntil( uint8_t terminator, uint8_t* buffer, size_t length )
   { return readBytesUntil( static_cast<char>(terminator), reinterpret_cast<char*>(buffer), length ); }
 
 
    size_t readLine( char *buffer, size_t length );
 
 
    void consumeWhiteSpace();
 
 
private:
 
    // Number of milliseconds to wait for the next char before aborting timed read
    unsigned long mTimeOut;
 
    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
};
 
 
#endif