url parser

#include <iostream>
#include <string>
#include <algorithm>
#include <map>

enum key_e{WORD, OPERATOR};
struct Token{
    key_e key;
    std::string value;

    Token(key_e key):key(key){}
    Token(key_e key, std::string value):key(key), value(value){}
};
std::vector<Token> lex(const std::string& str){
    std::vector<Token> tokens;
    std::string value;
    enum{Begin, Word} state = Begin;

    for(char c : str){
        if(std::isalpha(c) || std::isdigit(c)){
            if(state == Begin)state = Word;
            value += c;
        }
        else if(std::isspace(c))break;
        else{
            if(state == Word){
                tokens.push_back({WORD, value});
                value.clear();
                state = Begin;
            }
            tokens.push_back({OPERATOR, {c}});
        }
    }
    if(state == Word)tokens.push_back({WORD, value});

    return std::move(tokens);
}
template <class Fnc>
bool parse(std::vector<Token>& tokens, const std::vector<Token>& pattern, Fnc fnc){
    if(tokens.size() < pattern.size())return false;

    if(std::equal(pattern.begin(), pattern.end(), tokens.begin(), [](const Token& p, const Token& t){
        return (p.key == t.key) && p.value.empty()?true:(p.value==t.value);
    })){
        fnc();
        tokens.erase(tokens.begin(), tokens.begin() + pattern.size());
        return true;
    }
    return false;
}

int main(){
    auto tokens = lex("https://domena.sk:80/cesta/cesta/subor.hpp ");
    std::map<std::string, std::string>   data{{"error", "false"}};
    //HTTP:
    parse(tokens, {WORD, {OPERATOR, ":"}, {OPERATOR, "/"}, {OPERATOR, "/"}}, [&](){
        data["http"] = tokens[0].value;
    });
    //DOMENA:
    while(parse(tokens, {WORD, {OPERATOR, "."}}, [&](){
        data["domena"] += tokens[0].value;
        data["domena"] += tokens[1].value;
    }));
    if(parse(tokens, {WORD}, [&](){
        if(data["domena"].empty()){
            data["error"] = "true";
            data["domena"] = "<error>";
        }
        data["domena"] += tokens[0].value;
    }));
    else{
        data["error"] = "true";
        data["domena"] += "<error>";
    }
    //PORT:
    parse(tokens, {{OPERATOR, ":"}, WORD}, [&](){
        data["port"] = tokens[1].value;
    });
    //CESTA & SUBOR:
    while(parse(tokens, {{OPERATOR, "/"}, WORD}, [&](){
        if(data["subor"].size())data["cesta"] += tokens[0].value;
        data["cesta"] += data["subor"];
        data["subor"] = tokens[1].value;
    }));
    //PRIPONA SUBORU:
    if(parse(tokens, {{OPERATOR, "."}, WORD}, [&](){
    data["subor"] += tokens[0].value;
        data["subor"] += tokens[1].value;
    }));

    if(tokens.size())data["error"] = "true";
    for(auto&d : data)std::cout << d.first << ": " << d.second << std::endl;
}