advanced_scan.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "token.h"
#include "scan.h"
 
#include "lib_begin.h"
 
namespace cgv {
    namespace utils {
 
struct line : public token
{
    line(const char* _b = 0, const char* _e = 0) : token(_b, _e) {}
};
 
enum token_type {
    PLAIN, URL, FLOAT_VALUE, TIME_VALUE, DATE_VALUE
};
 
struct typed_token : public token
{
    token_type type;
    typed_token(const token& t, token_type tt = PLAIN) : token(t), type(tt), date_value(0) {}
    double float_value;
    utils::time time_value;
    utils::date date_value;
};
 
extern CGV_API void split_to_tokens(
            const char* begin, const char* end,
            std::vector<token>& tokens,
            const std::string& separators, 
            bool merge_separators = true,
            const std::string& open_parenthesis = "", const std::string& close_parenthesis = "", 
            const std::string& whitespaces = " \t\n",
            unsigned int max_nr_tokens = -1);
 
inline void split_to_tokens(
            const token& tok,
            std::vector<token>& tokens,
            const std::string& separators, 
            bool merge_separators = true,
            const std::string& open_parenthesis = "", const std::string& close_parenthesis = "", 
            const std::string& whitespaces = " \t\n",
            unsigned int /*max_nr_tokens*/ = -1) 
{
    split_to_tokens(
        tok.begin,tok.end,
        tokens,
        separators,merge_separators,open_parenthesis,close_parenthesis,whitespaces); 
}
 
inline void split_to_tokens(
            const std::string& s,
            std::vector<token>& tokens,
            const std::string& separators, 
            bool merge_separators = true,
            const std::string& open_parenthesis = "", const std::string& close_parenthesis = "", 
            const std::string& whitespaces = " \t\n",
            unsigned int /*max_nr_tokens*/ = (unsigned int)-1)
{
    split_to_tokens(&s[0],&s[0]+s.size(),tokens,separators,merge_separators,open_parenthesis,close_parenthesis,whitespaces);
}
 
extern CGV_API void split_to_lines(const char* begin, const char* end, 
                                              std::vector<line>& lines, 
                                              bool truncate_trailing_spaces = true);
inline void split_to_lines(const token& tok, 
                                              std::vector<line>& lines, 
                                              bool truncate_trailing_spaces = true) { 
    split_to_lines(tok.begin,tok.end,lines,truncate_trailing_spaces); 
}
 
inline void split_to_lines(const std::string& s, 
                                              std::vector<line>& lines, 
                                              bool truncate_trailing_spaces = true) { 
    split_to_lines(&s[0],&s[0]+s.size(),lines,truncate_trailing_spaces); 
}
 
extern CGV_API bool balanced_find_content(
    const char* begin, const char* end, 
    token& content, 
    char open_parenthesis, char close_parenthesis);
 
inline bool balanced_find_content(
            const token& expression, 
            token& content, 
            char open_parenthesis, char close_parenthesis) {
    return balanced_find_content(expression.begin, expression.end,
        content,open_parenthesis,close_parenthesis);
}
inline bool balanced_find_content(
            const std::string& expression, 
            token& content, 
            char open_parenthesis, char close_parenthesis) {
    return balanced_find_content(&expression[0], &expression[0]+expression.size(),
        content,open_parenthesis,close_parenthesis);
}
 
extern CGV_API std::string strip_cpp_comments(const std::string& source, bool correct_new_lines = true);
 
    }
}
 
#include <cgv/config/lib_end.h>