scanner.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
#include <PropWare/hmi/input/scancapable.h>
#include <PropWare/hmi/output/printer.h>
#include <PropWare/utility/comparator.h>
 
extern "C" {
extern const char *_scanf_getl (const char *str, int *dst, int base, unsigned width, int isSigned);
extern const char *_scanf_getf (const char *str, float *dst);
}
 
namespace PropWare {
 
class Scanner {
    public:
        typedef enum {               NO_ERROR  = 0,    BEG_ERROR,       BAD_INPUT = BEG_ERROR,END_ERROR = BAD_INPUT
        } ErrorCode;
 
    public:
        static const char DEFAULT_DELIMITER  = '\n';
        static const char WHITESPACE_CHARS[]; 
 
    public:
        Scanner (ScanCapable &scanCapable, const Printer *printer = NULL)
            : m_scanCapable(&scanCapable),
              m_printer(printer) {
        }
 
        char get_char () {
            const char c = this->m_scanCapable->get_char();
            if (NULL != this->m_printer)
                this->m_printer->put_char(c);
            return c;
        }
 
        ErrorCode gets (char string[], int32_t length, const char delimiter = DEFAULT_DELIMITER) {
            char *buf = string;
            while (0 < --length) {
                char ch = this->m_scanCapable->get_char();
 
                if (ch == 8 || ch == 127) {
                    if (buf > string) {
                        if (NULL != this->m_printer)
                            this->m_printer->puts("\010 \010");
                        ++length;
                        --buf;
                    }
                    length += 1;
                    continue;
                }
 
                if (NULL != this->m_printer) {
                    this->m_printer->put_char(ch);
 
                    if ('\n' == delimiter && '\r' == ch)
                        this->m_printer->put_char('\n');
                }
 
                if (!ch || delimiter == ch || ('\n' == delimiter && '\r' == ch))
                    break;
                else
                    *(buf++) = ch;
            }
            *buf      = 0;
 
            return NO_ERROR;
        }
 
        ErrorCode get_token (char string[], int32_t length, const char *delimiters = WHITESPACE_CHARS) {
            char *buf = string;
            while (0 < --length) {
                const char ch = this->m_scanCapable->get_char();
 
                if (ch == 8 || ch == 127) {
                    if (buf > string) {
                        if (NULL != this->m_printer)
                            this->m_printer->puts("\010 \010");
                        ++length;
                        --buf;
                    }
                    length += 1;
                    continue;
                }
 
                if (NULL != this->m_printer) {
                    this->m_printer->put_char(ch);
                }
 
                if (!ch || strchr(delimiters, ch))
                    break;
                else
                    *(buf++) = ch;
            }
            *buf      = 0;
 
            return NO_ERROR;
        }
 
        template<typename T>
        Scanner &operator>> (T &c) {
            this->get(c);
            return *this;
        }
 
        const ErrorCode get (char &c) {
            ErrorCode err;
            char      userInput[2];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            if ('\0' == c)
                return BAD_INPUT;
            else {
                c = userInput[0];
                return NO_ERROR;
            }
        }
 
        const ErrorCode get (uint8_t &x) {
            ErrorCode err;
            char      userInput[32];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            int tmp;
            if (0 == _scanf_getl(userInput, &tmp, 10, 11, false))
                return BAD_INPUT;
            else {
                x = static_cast<uint8_t>(tmp);
                return NO_ERROR;
            }
        }
 
        template<size_t N>
        const ErrorCode get (char (&buffer)[N]) {
            return this->gets(buffer, N);
        }
 
        const ErrorCode get (uint16_t &x) {
            ErrorCode err;
            char      userInput[32];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            int tmp;
            if (0 == _scanf_getl(userInput, &tmp, 10, 11, false))
                return BAD_INPUT;
            else {
                x = static_cast<uint16_t>(tmp);
                return NO_ERROR;
            }
        }
 
        const ErrorCode get (int16_t &x) {
            ErrorCode err;
            char      userInput[32];
 
            check_errors(this->get_token(userInput, sizeof(userInput)));
            int tmp;
            if (0 == _scanf_getl(userInput, &tmp, 10, 11, false))
                return BAD_INPUT;
            else {
                x = static_cast<int16_t>(tmp);
                return NO_ERROR;
            }
        }
 
        const ErrorCode get (uint32_t &x) {
            ErrorCode err;
            char      userInput[32];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            if (0 == _scanf_getl(userInput, (int *) &x, 10, 11, false))
                return BAD_INPUT;
            else
                return NO_ERROR;
        }
 
        const ErrorCode get (int32_t &x) {
            ErrorCode err;
            char      userInput[32];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            if (0 == _scanf_getl(userInput, &x, 10, 11, false))
                return BAD_INPUT;
            else
                return NO_ERROR;
        }
 
        const ErrorCode get (float &f) {
            ErrorCode err;
            char      userInput[32];
            check_errors(this->get_token(userInput, sizeof(userInput)));
            if (0 == _scanf_getf(userInput, &f))
                return BAD_INPUT;
            else
                return NO_ERROR;
        }
 
        void input_prompt (const char prompt[], const char failureResponse[], char userInput[],
                           const size_t bufferLength, const Comparator<char> &comparator) {
            do {
                this->m_printer->puts(prompt);
                this->gets(userInput, bufferLength);
 
                if (comparator.valid(userInput))
                    return;
                else
                    this->m_printer->puts(failureResponse);
            } while (1);
        }
 
        template<typename T>
        void input_prompt (const char prompt[], const char failureResponse[], T *userInput,
                           const Comparator<T> &comparator) {
            const T   original = *userInput;
            ErrorCode err;
            do {
                this->m_printer->puts(prompt);
                err = this->get(*userInput);
                if (NO_ERROR == err && comparator.valid(userInput))
                    return;
 
                this->m_printer->puts(failureResponse);
                *userInput = original;
            } while (1);
        }
 
    private:
        ScanCapable   *m_scanCapable;
        const Printer *m_printer;
};
 
}
 
#ifndef __PROPELLER_COG__
extern PropWare::Scanner pwIn;
#endif