EasyScanner.h

Go to the documentation of this file.

 
#ifndef CNOID_UTIL_EASYSCANNER_H_INCLUDED
#define CNOID_UTIL_EASYSCANNER_H_INCLUDED
 
#include <unordered_map>
#include <string>
#include <vector>
#include <memory>
#include "exportdecl.h"
 
namespace cnoid {
 
class CNOID_EXPORT  EasyScanner {
 
public:
 
    class Endl {
        //int dummy;
    };
 
    class CNOID_EXPORT Exception {
public:
        std::string message;
        std::string filename;
        int lineNumber;
        std::string getFullMessage() const;
    };
 
    enum TokenType {
        T_NONE = 0, T_SPACE, T_ALPHABET, T_INTEGER, T_DOUBLE, T_WORD,
        T_STRING, T_SIGLUM, T_LF, T_EOF
    };
 
    typedef std::unordered_map<std::string, int> SymbolMap;
    typedef std::pair<std::string, int> SymbolPair;
 
    Endl endl;
 
    EasyScanner();
    EasyScanner(std::string filename);
    EasyScanner(const EasyScanner& org, bool copyText = false);
    virtual ~EasyScanner();
 
    void putSymbols();
 
    inline void registerSymbol(int id, const std::string& symbol) {
        symbols->insert(SymbolPair(symbol, id));
    }
 
    void setSymbols(std::shared_ptr<SymbolMap> symbols){
        this->symbols = symbols;
    }
 
    inline int  getSymbolID(const std::string& symbol) {
        SymbolMap::iterator p = symbols->find(symbol);
        return (p != symbols->end()) ? p->second : 0;
    }
 
    void setCommentChar(char cc);
 
    void setLineOriented(bool on);
    void setQuoteChar(char qc);
    void setWhiteSpaceChar(char ws);
 
    void loadFile(const std::string& filename);
 
    void setText(const char* text, size_t len);
 
    void setLineNumberOffset(int offset);
 
    void setDefaultErrorMessage(const std::string& message){
        defaultErrorMessage = message;
    }
 
    void moveToHead();
 
    int  readToken();
 
    void toLower();
 
    bool readFloat();
    bool readDouble();
    bool readInt();
    bool readChar();
    bool readChar(int chara);
    int  peekChar();
 
    inline bool readWord() {
        skipSpace();
        return readWord0();
    }
 
    inline bool readString(const int delimiterChar = ',') {
        skipSpace();
        return readString0(delimiterChar);
    }
 
    bool readString(const char* str);
 
    inline bool readString(const std::string& str) {
        return readString(str.c_str());
    }
 
    bool readQuotedString(bool allowNoQuotedWord = false);
 
    bool readUnquotedTextBlock();
 
    bool readSymbol();
    bool readSymbol(int id);
 
    inline bool isEOF(){
        skipSpace();
        return (*text == '\0');
    }
 
    inline bool readLF() {
        skipSpace();
        return readLF0();
    }
 
    inline bool readLFEOF() {
        skipSpace();
        return readLF0() ? true : (*text == '\0');
    }
 
    bool checkLF();
 
    bool readLine();
    bool skipLine();
    bool skipBlankLines();
    void skipToLineEnd();
 
    void skipSpace();
 
    void throwException(const char* message);
    void throwException(const std::string& message);
 
    inline int readIntEx(const char* message = 0) {
        if(!readInt()) throwException(message);
        return intValue;
    }
    inline double readDoubleEx(const char* message = 0) {
        if(!readDouble()) throwException(message);
        return doubleValue;
    }
    inline float readFloatEx(const char* message = 0) {
        if(!readFloat()) throwException(message);
        return floatValue;
    }
    inline int readCharEx(const char* message = 0) {
        if(!readChar())
            throwException(message);
        return charValue;
    }
    inline void readCharEx(int chara, const char* message = 0) {
        if(!readChar(chara)) throwException(message);
    }
    inline const std::string& readWordEx(const char* message = 0) {
        if(!readWord()) throwException(message);
        return stringValue;
    }
 
    inline void checkStringEx(const char* str, const char* message = 0){
        if(!readString(str)) throwException(message);
    }
 
    inline const std::string& readStringEx(const char* message = 0) {
        if(!readString()) throwException(message);
        return stringValue;
    }
 
    inline const std::string& readQuotedStringEx(const char* message = 0) {
        if(!readQuotedString()) throwException(message);
        return stringValue;
    }
    inline int readSymbolEx(const char* message = 0) {
        if(!readSymbol()) throwException(message);
        return symbolValue;
    }
    inline void readLFex(const char* message = 0) {
        if(!readLF()) throwException(message);
    }
 
    inline void readLFEOFex(const char* message = 0) {
        if(!readLFEOF()) throwException(message);
    }
 
    int intValue;
    double doubleValue;
    float floatValue;
    std::string stringValue;
    char charValue;
    int symbolValue;
 
    std::string defaultErrorMessage;
    int lineNumber;
 
    char* text;
 
    std::string filename;
 
private:
    void init();
    bool extractQuotedString();
 
    bool readLF0();
    bool readWord0();
    bool readString0(const int delimiterChar);
    
    char* textBuf;
    size_t size;
    char* textBufEnd;
    int lineNumberOffset;
    int commentChar;
    int quoteChar;
    bool isLineOriented;
 
    std::vector<int> whiteSpaceChars;
 
    std::shared_ptr<SymbolMap> symbols;
 
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, double& value);
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, int& value);
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, const char* matchString);
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, char matchChar);
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, std::string& str);
    friend CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, EasyScanner::Endl endl);
 
};
 
 
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, double& value);
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, int& value);
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, const char* matchString);
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, char matchChar);
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, std::string& str);
CNOID_EXPORT EasyScanner& operator>>(EasyScanner& scanner, EasyScanner::Endl endl);
}
 
#endif