boost - boost boost::spirit::qi以使用STL容器-6ren

boost - boost boost::spirit::qi以使用STL容器

转载作者：行者123 更新时间：2023-12-04 13:32:46

我正在尝试使用boost.spirit的qi库解析某些内容，而我遇到了一个问题。根据spirit docs，a >> b应该产生类型为tuple<A, B>的东西。但这是boost::tuple(又名 fusion 矢量)，而不是std::tuple(我想要的)。

有什么简单的方法可以在boost::tuple => std::tuple之间进行转换？

在同一文档页面上，*a应该产生类型为vector<A>的东西。这似乎正在生成std::vector<A>(或可以隐式转换为boost::vector<A>的某种std::vector<A>)。我只是想知道这种相同的行为是否适用于元组。

最佳答案

简短答案:

使用#include <boost/fusion/adapted/std_tuple.hpp>。

更多完整的答案:

如您所见here:

In the attribute tables, we will use vector<A> and tuple<A, B...> as placeholders only. The notation of vector<A> stands for any STL container holding elements of type A and the notation tuple<A, B...> stands for any Boost.Fusion sequence holding A, B, ... etc. elements. Finally, Unused stands for unused_type.

因此，当解析器/生成器的属性为 tuple<A,B...>时，您可以使用任何 fusion 序列(例如fusion::vector或fusion::list)或任何可以适应 fusion 序列的东西(例如boost::array，boost: :tuple，std::pair，std::tuple，您自己的结构体(使用BOOST_FUSION_ADAPT_STRUCT)。

当它具有 vector<A>时，如果您的元素是成对的，则可以使用std::vector，std::list甚至std::map。如果您还专门化了几个定制点(至少在boost::spirit::traits中是is_container，container_value和push_back_container)，则也可以使用自己的结构。

std::pair
为了能够在 spirit 上使用 std::pair，您只需要添加一个 header 即可:

#include <boost/fusion/include/std_pair.hpp>
...
qi::rule<Iterator,std::pair<int,double>()> rule = 
    qi::int_ >> qi::lit(',') >> qi::double_;

std::tuple
从boost 1.48.0开始，您可以对std::tuple执行相同的操作:

#include <boost/fusion/adapted/std_tuple.hpp> 
...
qi::rule<Iterator,std::tuple<int,std::string,double>()> rule =
    qi::int_ >> qi::lit(',') >> +~qi::char_(',') >> qi::lit(',') >> qi::double_;

您自己的结构
您可以借助BOOST_FUSION_ADAPT_STRUCT轻松调整自定义结构:

#include <boost/fusion/include/adapt_struct.hpp>
...
struct normal_struct
{
    int integer;
    double real;
};

BOOST_FUSION_ADAPT_STRUCT(
    normal_struct,
    (int, integer)
    (double, real)
)
...
qi::rule<Iterator,normal_struct()> rule =
    qi::int_ >> qi::lit(',') >> qi::double_;

但是，有一个已知的限制，当您尝试使用具有单个元素的结构时，除非容器中添加了 qi::eps >> ...，否则容器编译也会失败。

struct struct_with_single_element_container
{
    std::vector<int> cont;
};

BOOST_FUSION_ADAPT_STRUCT(
    struct_with_single_element_container,
    (std::vector<int>, cont)
)
...
qi::rule<Iterator,struct_with_single_element_container()> rule =
    qi::eps >> qi::int_%qi::lit(',');

std::map
您可以简单地将std::map用作std::pairs的容器。但是请记住，如果输入中有重复的键，则只会将第一个键插入到 map 中(如果使用多图，则当然会插入所有内容):

#include <boost/fusion/include/std_pair.hpp>
...
qi::rule<std::string::const_iterator, std::pair<double,int>()> pair_rule = 
    qi::double_ >> qi::lit('=') >> qi::int_;
qi::rule<std::string::const_iterator, std::map<double,int>()> rule = 
    pair_rule%qi::lit(',');
//You can also use
//qi::rule<std::string::const_iterator, std::map<double,int>()> rule =
    //(qi::double_ >> qi::lit('=') >> qi::int_)%qi::lit(',');

您自己的结构作为容器
使用Spirit的 customization points，还可以使您的结构在处理属性时像容器一样工作。您需要专门研究的最低要求是 is_container， container_value和 push_back_container。以下是几个示例:

第一个很简单(而且很愚蠢)。它使您的结构具有与 std::vector<int>兼容的属性。每次解析一个int都会将其添加到累加器的总数中。您可以发现 here和 here少一些愚蠢的方法(在“旧答案”中)。

struct accumulator
{
    accumulator(): total(){}
    int total;
};

namespace boost{ namespace spirit{ namespace traits
{
    template<>
    struct is_container<accumulator> : boost::mpl::true_
    {};

    template<>
    struct container_value<accumulator>
    {
        typedef int type;
    };

    template<>
    struct push_back_container<accumulator,int>
    {
        static bool call(accumulator& c, int val)
        {
            c.total+=val;
            return true;
        }
    };
}}}
...
qi::rule<Iterator,accumulator()> rule =
    qi::int_%qi::lit(',');

第二个比较复杂(不多)。它使您的结构具有与 std::vector<boost::variant<int,std::string> >兼容的属性。解析一个int时，会将其添加到分发服务器中的 ints容器中，类似地，字符串也存储在 strings容器中。使用此示例( 1， 2和 3)。

struct distributor
{
    distributor():ints(),strings(){}
    std::vector<int> ints;
    std::vector<std::string> strings;
};

namespace boost{ namespace spirit{ namespace traits
{
    template<>
    struct is_container<distributor> : boost::mpl::true_
    {};

    template<>
    struct container_value<distributor>
    {
        typedef boost::variant<int,std::string> type;
    };

    template<>
    struct push_back_container<distributor,int>
    {
        static bool call(distributor& c, int val)
        {
            c.ints.push_back(val);
            return true;
        }
    };

    template<>
    struct push_back_container<distributor,std::string>
    {
        static bool call(distributor& c, std::string const& val)
        {
            c.strings.push_back(val);
            return true;
        }
    };
}}}
...
qi::rule<std::string::const_iterator, std::string()> string_rule = 
    +~qi::char_(',');
qi::rule<std::string::const_iterator, distributor()> rule = 
    (qi::int_ | string_rule)%qi::lit(',');

所有测试均在单个cpp文件中

#include <iostream>
#include <string>
#include <utility>
#include <tuple>
#include <list>
#include <vector>
#include <map>

#include <boost/fusion/include/std_pair.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/adapted/std_tuple.hpp> 

#include <boost/spirit/include/qi.hpp>

#include <boost/variant.hpp>

namespace qi=boost::spirit::qi;

struct normal_struct
{
    int integer;
    double real;
};

struct struct_with_single_element_container
{
    std::vector<int> cont;
};

BOOST_FUSION_ADAPT_STRUCT(
    normal_struct,
    (int, integer)
    (double, real)
)

BOOST_FUSION_ADAPT_STRUCT(
    struct_with_single_element_container,
    (std::vector<int>, cont)
)

struct accumulator
{
    accumulator(): total(){}
    int total;
};

namespace boost{ namespace spirit{ namespace traits
{
    template<>
    struct is_container<accumulator> : boost::mpl::true_
    {};

    template<>
    struct container_value<accumulator>
    {
        typedef int type;
    };

    template<>
    struct push_back_container<accumulator,int>
    {
        static bool call(accumulator& c, int val)
        {
            c.total+=val;
            return true;
        }
    };
}}}

struct distributor
{
    distributor():ints(),strings(){}
    std::vector<int> ints;
    std::vector<std::string> strings;
};

namespace boost{ namespace spirit{ namespace traits
{
    template<>
    struct is_container<distributor> : boost::mpl::true_
    {};

    template<>
    struct container_value<distributor>
    {
        typedef boost::variant<int,std::string> type;
    };

    template<>
    struct push_back_container<distributor,int>
    {
        static bool call(distributor& c, int val)
        {
            c.ints.push_back(val);
            return true;
        }
    };

    template<>
    struct push_back_container<distributor,std::string>
    {
        static bool call(distributor& c, std::string const& val)
        {
            c.strings.push_back(val);
            return true;
        }
    };
}}}


int main()
{
    {
        std::pair<int,double> parsed;
        qi::rule<std::string::const_iterator, std::pair<int,double>()> rule = 
                    qi::int_ >> qi::lit(',') >> qi::double_;
        std::string test="1,2.5";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "First: " << parsed.first << ", Second: " << parsed.second << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        std::tuple<int,std::string,double> parsed;
        qi::rule<std::string::const_iterator, std::tuple<int,std::string,double>()> rule = 
                    qi::int_ >> qi::lit(',') >> +~qi::char_(',') >> qi::lit(',') >> qi::double_;
        std::string test="1,abc,2.5";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "get<0>: " << std::get<0>(parsed) << ", get<1>: " << std::get<1>(parsed) << ", get<2>: " << std::get<2>(parsed) << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        normal_struct parsed;
        qi::rule<std::string::const_iterator, normal_struct()> rule = 
                    qi::int_ >> qi::lit(',') >> qi::double_;
        std::string test="1,2.5";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "integer: " << parsed.integer << ", real: " << parsed.real << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        struct_with_single_element_container parsed;
        //there is a problem when you have a struct with a single element container, the workaround is simply adding qi::eps to the rule
        qi::rule<std::string::const_iterator, struct_with_single_element_container()> rule = 
                    qi::eps >> qi::int_%qi::lit(','); 
        std::string test="1,2";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "[0]: " << parsed.cont[0] << ", [1]: " << parsed.cont[1] << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        std::list<int> parsed;
        qi::rule<std::string::const_iterator, std::list<int>()> rule = 
                    qi::int_%qi::lit(',');
        std::string test="1,2";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "front: " << parsed.front() << ", back: " << parsed.back() << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        std::map<double,int> parsed;
        qi::rule<std::string::const_iterator, std::pair<double,int>()> pair_rule = 
                    qi::double_ >> qi::lit('=') >> qi::int_;
        qi::rule<std::string::const_iterator, std::map<double,int>()> rule = 
                    pair_rule%qi::lit(',');
        std::string test="2.5=1,3.5=2";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "map[2.5]: " << parsed[2.5] << ", map[3.5]: " << parsed[3.5] << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        accumulator parsed;
        qi::rule<std::string::const_iterator, accumulator()> rule = 
                    qi::int_%qi::lit(',');
        std::string test="1,2,3";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "total: " << parsed.total << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

    {
        distributor parsed;
        qi::rule<std::string::const_iterator, std::string()> string_rule = 
                    +~qi::char_(',');
        qi::rule<std::string::const_iterator, distributor()> rule = 
                    (qi::int_ | string_rule)%qi::lit(',');
        std::string test="abc,1,2,def,ghi,3,jkl";
        std::string::const_iterator iter=test.begin(), end=test.end();
        bool result = qi::parse(iter,end,rule,parsed);
        if(result && iter==end)
        {
            std::cout << "Success." << std::endl;
            std::cout << "ints" << std::endl;
            for(auto val: parsed.ints)
                std::cout << val << std::endl;
            std::cout << "strings" << std::endl;
            for(const auto& val: parsed.strings)
                std::cout << val << std::endl;
        }
        else
        {
            std::cout << "Failure." << std::endl;
            std::cout << "Unparsed: " << std::string(iter,end) << std::endl;
        }
    }

}

关于boost - boost boost::spirit::qi以使用STL容器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18158376/

文章推荐： datagridview - 从 SQLReader 填充 DataGridView

文章推荐： json.net - 如何检查对象是 JProperty 还是 JArray

文章推荐： laravel - Laravel 4 : Route to localhost/controller/action

c++ - 如何在 x3 中用 qi::_1/qi::_N 重写 qi 解析器？
假设我们要解析一个内积表达式并得到结果。 "SUM({1, 2, 3} .* {4, 5, 6})" qi::_1 和 qi::_2 非常方便地在解析器中引用第 i 个属性。 void Test(st
c++ - boost qi 属性出现为 qi::unused_type
无法弄清楚为什么这条规则 unary_msg 不起作用，它说属性类型是 qi::unused_type 但这对我来说毫无意义。为什么 boost 会这样折磨我？ template struct g3:
boost-spirit-qi - qi::uint_parser() 应该准确解析什么？
从测试中我可以得到 qi::uint_parser()与 qi::uint_ 相同.他们从 0 解析整数至 UINT_MAX . 我不明白的是qi::uint_parser需要 std::numeri
c++ - qi::phrase_parse 返回真，即使调用了 qi::on_error
bool EqnExprEvaluator::SetEqn(const std::string& eqnStr) { typedef std::string::const_iterator
c++ - 将 qi::lexeme 添加到 spirit qi 中的规则时编译失败
我一直在使用 Boost 库中的 Spirit Qi 用 C++ 编写语法。作为该语言的新手，很难习惯该库的语法和怪癖，但现在我有点了解它的工作原理。我在使用 qi::lexeme 时遇到错误。我的
c++ - 使用 Boost Spirit Qi qi::iter_pos 但无法捕获值
我需要跟踪一些项目在我使用提升灵气解析的文本中的位置。我找到了 this example并适应这样: #include #include #include #include #include
c++ - boost::spirit: qi::rule 或包含 qi::rule 作为解析结果的结构
我想做的是在运行时从 ABNF 语法文件创建一个解析器。我已经在 qi::grammar 中实现了所有 ABNF 规则，如下所示: typedef /*qi::rule or struct conta
c++ - C 风格字符串的 boost::spirit::qi 和 qi::alnum 的模板编译错误
我在boost_1.59中使用spirit来解析类c语言(名为stone，最初由java编写)。但是我在使用 boost::spirit::qi 解析 c 风格的字符串时遇到了麻烦。整个代码位于 co
c++ - 使用带有 qi::grammar 的 boost::spirit::qi::phrase_parse() 时出错
我正在用 Boost.Spirit 做一个 IRC 消息解析器，但是当我尝试解析一个输入时我遇到了一个(很长的)错误。我遵循了“Roman Numerals”示例。此外，我将 g++4.7 与 -st
c++ - boost::spirit::qi::double_ 和 boost::spirit::qi::int_
如何解析可能包含 double 或 int 的字符串，具体取决于是否设置了点。例如。 6.0是double类型，6是int类型。规则是 rule,skipper> r = qi::double_|qi
c++ - 指示 Qi 转换属性失败的正确方法是什么？
在 boost::spirit::traits::transform_attribute 中指示解析失败的正确方法是什么？我可以抛出任何旧的异常，还是它要我做的特定事情？ namespace boos
c++ - 如何使用 qi 创建通用解析器？
我正在尝试使用 qi 创建通用解析器元素，因为不幸的是(必须支持 MSVC)无法使用 X3。这个想法是有一个模板化的结构: template struct parse_type; 我可以这样使用: t
c++ - 使用函数属性构建 qi::rule
我正在尝试创建一个返回 function 的规则通过柯里化(Currying) Phoenix 表达式构造。例如， start = int_[_val = xxx]; rule start; 应该做什
c++ - 如何使用 qi 解析和验证有序的整数列表
我正在解析一个文本文件，可能有几 GB 的大小，由以下几行组成: 11 0.1 14 0.78 532 -3.5 基本上，每行一个整数和一个 float 。整数应该是有序的并且是非负的。我想验证数据是
c++ - Qi Symbols 性能慢？
我想提出一个让我陷入困境的主题，并提出了一个关于齐::符号。这一切都始于我查看新的野兽图书馆并阅读 atutorial example 它以一个从 http 路径猜测 mime 类型的函数开始扩展。
c++ - 如何确保此 qi 解析器不允许点运算符之间有空格？
我有一段 boost::spirit::qi 代码可以匹配 "M7.x.y.z" 或 "M7.x.y.z "，但我想要一个在前一个输入上失败的解析器。我想我需要在其中插入 qi::lexeme[]
c++ - Boost Qi 使用函数编写规则
我正在尝试为一种语言的多个子集定义一些 Boost::spirit::qi 解析器，代码重复最少。为此，我创建了一些基本的规则构建函数。原来的解析器工作正常，但一旦我开始使用组合函数，我的解析器似乎就
c++ - Boost.Qi 规则是否总是在使用它们的表达式中通过引用保存？
假设我有一个简单的类型foo: struct foo { void bar(int) { // do something } }; 我想使用 Boost.Qi 来解析字符串中的整数字段，并使用结果值调
c++ - 尝试将整数解析为字符串 (qi::as_wstring)
(免责声明，我正在学习提升精神) 我正在尝试解析这样的表达式:F( 1 ) 并希望将 1 作为字符串(“1”而不是数字(与 qi::int_ 一起使用))。我试过这样的事情(这是错误的，但也许我的方
c++ - 在 Qi 中对解析器公开的属性应用操作
假设我有两个用逗号分隔的 double 来解析返回它们的总和。在 Haskell 中我可能会这样做: import Data.Attoparsec.Text import Data.Text (pac

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

boost - boost boost::spirit::qi以使用STL容器