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);
}
 
        }
}
 
#include <cgv/config/lib_end.h>