ClickHouse/base/poco/Foundation/include/Poco/Token.h

//
// Token.h
//
// Library: Foundation
// Package: Streams
// Module:  StreamTokenizer
//
// Definition of the Token class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:	BSL-1.0
//


#ifndef Foundation_Token_INCLUDED
#define Foundation_Token_INCLUDED


#include <istream>
#include "Poco/Foundation.h"


namespace Poco
{


class Foundation_API Token
/// The base class for all token classes that can be
/// registered with the StreamTokenizer.
{
public:
    enum Class
    {
        IDENTIFIER_TOKEN,
        KEYWORD_TOKEN,
        SEPARATOR_TOKEN,
        OPERATOR_TOKEN,
        STRING_LITERAL_TOKEN,
        CHAR_LITERAL_TOKEN,
        INTEGER_LITERAL_TOKEN,
        LONG_INTEGER_LITERAL_TOKEN,
        FLOAT_LITERAL_TOKEN,
        DOUBLE_LITERAL_TOKEN,
        COMMENT_TOKEN,
        SPECIAL_COMMENT_TOKEN,
        PREPROCESSOR_TOKEN,
        WHITESPACE_TOKEN,
        EOF_TOKEN,
        INVALID_TOKEN,
        USER_TOKEN
    };

    Token();
    /// Creates the Token.

    virtual ~Token();
    /// Destroys the Token.

    virtual bool start(char c, std::istream & istr);
    /// Checks if the given character (and, optionally,
    /// the next character in the input stream) start
    /// a valid token. Returns true if so, false
    /// otherwise.
    ///
    /// The current read position in istr must not be
    /// changed. In other words, only the peek() method
    /// of istream may be used.
    ///
    /// If the character starts the token, it should
    /// be set as the token's value.

    virtual void finish(std::istream & istr);
    /// Builds the token by reading and appending
    /// the remaining characters from istr.

    virtual Class tokenClass() const;
    /// Returns the kind of the token.

    const std::string & tokenString() const;
    /// Returns the token's raw string.

    virtual std::string asString() const;
    /// Returns a string representation of the token.

    virtual Int64 asInteger64() const;
    /// Returns a 64-bit integer representation of the token.

    virtual UInt64 asUnsignedInteger64() const;
    /// Returns an unsigned 64-bit integer representation of the token.

    virtual int asInteger() const;
    /// Returns an integer representation of the token.

    virtual unsigned asUnsignedInteger() const;
    /// Returns an unsigned integer representation of the token.

    virtual double asFloat() const;
    /// Returns a floating-point representation of the token.

    virtual char asChar() const;
    /// Returns a char representation of the token.

    bool is(Class tokenClass) const;
    /// Returns true iff the token has the given class.

protected:
    std::string _value;

private:
    Token(const Token &);
    Token & operator=(const Token &);
};


class Foundation_API InvalidToken : public Token
/// This token class is used for signalling that
/// an invalid character sequence has been encountered
/// in the input stream.
{
public:
    InvalidToken();
    ~InvalidToken();
    Class tokenClass() const;
};


class Foundation_API EOFToken : public Token
/// This token class is used to signal the
/// end of the input stream.
{
public:
    EOFToken();
    ~EOFToken();
    Class tokenClass() const;
};


class Foundation_API WhitespaceToken : public Token
/// This pseudo token class is used to eat
/// up whitespace in between real tokens.
{
public:
    WhitespaceToken();
    ~WhitespaceToken();
    Class tokenClass() const;
    bool start(char c, std::istream & istr);
    void finish(std::istream & istr);
};


//
// inlines
//
inline const std::string & Token::tokenString() const
{
    return _value;
}


inline bool Token::is(Token::Class cls) const
{
    return tokenClass() == cls;
}


} // namespace Poco


#endif // Foundation_Token_INCLUDED