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