如何使用Boost Spirit实现Boost UUID解析器？

我之前也碰到过用Spirit Qi解析UUID的类似坑，先给你两个可行的实现方案，再拆解你遇到的问题原因：

方案一：利用现成的UUID字符串解析器（简单高效） #

既然Boost UUID库已经提供了string_generator可以处理各种格式的UUID（带大括号、带横杠、纯十六进制都支持），我们可以结合Spirit的raw规则来准确匹配UUID的字符序列，再通过语义动作调用string_generator生成UUID。这种方式既保证迭代器正确前进，又不用自己写十六进制转换逻辑：

#include <boost/spirit/include/qi.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/string_generator.hpp>
#include <iostream>
#include <string>

namespace qi = boost::spirit::qi;
namespace uuid = boost::uuids;

template <typename Iterator>
struct uuid_parser : qi::grammar<Iterator, uuid::uuid()> {
    uuid_parser() : uuid_parser::base_type(start) {
        using qi::raw;
        using qi::char_;
        using qi::_val;
        using qi::_1;

        // 精确匹配UUID的所有合法格式
        uuid_format = 
            -(char_("{("))  // 可选的左大括号/括号
            >> repeat(8)[char_("0-9a-fA-F")] >> -char_('-')
            >> repeat(4)[char_("0-9a-fA-F")] >> -char_('-')
            >> repeat(4)[char_("0-9a-fA-F")] >> -char_('-')
            >> repeat(4)[char_("0-9a-fA-F")] >> -char_('-')
            >> repeat(12)[char_("0-9a-fA-F")]
            >> -(char_(")}"));  // 可选的右大括号/括号

        // 用raw获取匹配的字符串，再通过string_generator转换为UUID
        start = raw[uuid_format][([&](std::string const& s) {
            try {
                uuid::string_generator gen;
                _val = gen(s);
            } catch (...) {
                qi::_pass = false; // 解析失败时标记为不匹配
            }
        })];
    }

private:
    qi::rule<Iterator, uuid::uuid()> start;
    qi::rule<Iterator, std::string()> uuid_format;
};

// 测试代码
int main() {
    std::string test_cases[] = {
        "123e4567-e89b-12d3-a456-426614174000",
        "{123e4567-e89b-12d3-a456-426614174000}",
        "(123e4567-e89b-12d3-a456-426614174000)",
        "123e4567e89b12d3a456426614174000",
        "{123e4567e89b12d3a456426614174000}"
    };

    uuid_parser<std::string::const_iterator> parser;

    for (auto const& input : test_cases) {
        std::string::const_iterator it = input.begin(), end = input.end();
        uuid::uuid result;
        bool success = qi::parse(it, end, parser, result);
        
        if (success && it == end) {
            std::cout << "✅ 解析成功: " << result << "\n";
        } else {
            std::cout << "❌ 解析失败: '" << input << "'\n";
            if (it != end) {
                std::cout << "   剩余未解析内容: '" << std::string(it, end) << "'\n";
            }
        }
    }
    return 0;
}

方案二：手动解析十六进制字节（无额外字符串拷贝） #

如果追求极致性能，不想做字符串拷贝，可以直接解析每个十六进制字节对，手动填充到uuid::uuid的数组中。这里需要用Spirit的局部变量跟踪当前填充的字节索引：

#include <boost/spirit/include/qi.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <iostream>
#include <string>

namespace qi = boost::spirit::qi;
namespace uuid = boost::uuids;

template <typename Iterator>
struct uuid_parser : qi::grammar<Iterator, uuid::uuid(), qi::locals<size_t>> {
    uuid_parser() : uuid_parser::base_type(start) {
        using qi::hex;
        using qi::char_;
        using qi::_val;
        using qi::_1;
        using qi::_a;

        // 解析单个字节（两个十六进制字符），并填充到uuid的对应位置
        byte = hex[
            _pass = (_a < 16),  // 确保不越界
            _val[_a++] = _1     // 赋值到当前索引的字节
        ];

        auto dash = -char_('-'); // 可选的分隔符横杠
        start = 
            -(char_("{("))
            >> repeat(4)[byte] >> dash
            >> repeat(2)[byte] >> dash
            >> repeat(2)[byte] >> dash
            >> repeat(2)[byte] >> dash
            >> repeat(6)[byte]
            >> -(char_(")}"))
            >> qi::eps[_a = 0]; // 重置局部索引，避免重复解析时出错
    }

private:
    qi::rule<Iterator, uuid::uuid(), qi::locals<size_t>> start;
    qi::rule<Iterator, unsigned char(), qi::locals<size_t>> byte;
};

// 测试代码和方案一相同，这里省略

你之前遇到的问题原因拆解 #

1. boost::conversion::try_lexical_convert的迭代器问题
   这个函数是尝试把整个输入字符串转换为UUID，它不会关心Spirit的迭代器位置——比如如果输入是"id: {123...}"，它会尝试把整个字符串转换，而不是只消耗UUID部分，导致迭代器停在开头，后续解析完全混乱。

2. UUID无insert成员的编译错误
   boost::uuids::uuid本质是一个固定大小的字节数组（16字节），不是标准的可插入容器（没有insert方法）。当你直接把Spirit规则的属性设为uuid::uuid()时，Spirit默认的容器处理逻辑会尝试调用insert来填充元素，这就触发了编译错误。解决的核心是不让Spirit自动处理容器赋值，而是通过语义动作手动填充。

3. BOOST_FUSION_ADAPT_ADT方案失败
   FUSION_ADAPT_ADT主要用于适配有getter/setter方法的类，而uuid::uuid只有operator[]来访问元素，没有对应的get/set接口。而且适配16个字节的工作量极大，即使适配成功，Spirit的容器处理逻辑还是会尝试用插入方式，依然会出错。

内容的提问来源于stack exchange，提问作者Superlokkus