3

我正在尝试在 Karma 生成器中使用 a boost::variantwithin a boost::optional。我已经能够将问题简化为：

using FooVariant = boost::variant<int>;
using FooOptional = boost::optional<FooVariant>;

template<typename OutputIt = boost::spirit::ostream_iterator>
struct FooGenerator
    : boost::spirit::karma::grammar<OutputIt, FooOptional()>
{
    FooGenerator()
        : FooGenerator::base_type(start_)
    {
        namespace bsk = boost::spirit::karma;
        start_ = '[' << ( bsk::int_ | '*' ) << ']';
    }

    boost::spirit::karma::rule<OutputIt, FooOptional()> start_;
};

int main()
{
    FooOptional fop1;
    std::cout << boost::spirit::karma::format(FooGenerator<>(), fop1) << std::endl;

    FooOptional fop2 = FooVariant{123};
    std::cout << boost::spirit::karma::format(FooGenerator<>(), fop2) << std::endl;
}

这里的输出是：

[*]
[*]

这不是我所希望的。

我改变的第一件事就是或多或少地通过更改FooVariant为进行健全性检查：using FooVariant = int;. 这输出：

[*]
[123]

并且是我想看到的！所以在我的第一个代码中，变体只有一种类型，所以我尝试添加第二种类型，只是为了看看：

using FooVariant = boost::variant<int, double>;
...
start_ = '[' << ( ( bsk::int_ | bsk::double_ ) | '*' ) << ']';

但随后我们回到：

[*]
[*]

然后我尝试为该变体添加一个专门的规则：

using FooVariant = boost::variant<int, double>;
using FooOptional = boost::optional<FooVariant>;

template<typename OutputIt = boost::spirit::ostream_iterator>
struct FooGenerator
    : boost::spirit::karma::grammar<OutputIt, FooOptional()>
{
    FooGenerator()
        : FooGenerator::base_type(start_)
    {
        namespace bsk = boost::spirit::karma;
        foovar_ = (bsk::int_ | bsk::double_);
        start_ = '[' << ( foovar_ | '*' ) << ']';
    }

    boost::spirit::karma::rule<OutputIt, FooVariant()> foovar_;
    boost::spirit::karma::rule<OutputIt, FooOptional()> start_;
};

int main()
{
    FooOptional fop1;
    std::cout << boost::spirit::karma::format(FooGenerator<>(), fop1) << std::endl;

    FooOptional fop2 = FooVariant{123};
    std::cout << boost::spirit::karma::format(FooGenerator<>(), fop2) << std::endl;
}

这给出了编译错误：

alternative_function.hpp:127:34: error: no member named 'is_compatible' in
      'boost::spirit::traits::compute_compatible_component<boost::variant<int, double>, boost::optional<boost::variant<int, double> >, boost::spirit::karma::domain>'
            if (!component_type::is_compatible(spirit::traits::which(attr_)))
                 ~~~~~~~~~~~~~~~~^

看起来模板生成正在尝试确保boost::variantandboost::optional兼容，但对我来说，问题是“为什么要确保它们完全兼容？”

我怎样才能使这项工作？

4

1 回答 1

4

我在另一个答案中告诉过你我将如何处理这个问题：Boost Karma: generate default text when boost::optional is unset

这不仅回避了这个问题，而且还简化了 AST/数据类型。

现在，既然你强迫我¹，我就挖了。问题出在foovar_ | '|'一个替代表达式的事实，它以某种方式验证了该属性必须是兼容的。在该检查期间，假设

  • 如果a有属性attr(a)并且b有属性attr(b)那么
  • a | b应该有variant<attr(a), attr(b)

它确实进行了一些逻辑检查（例如 when attr(a) == attr(b)），但没有进行逻辑检查 if attr(b)is unused_typethen 它应该与optional<attr(a)>too 兼容，而不仅仅是 withvariant<attr(a), unused_type>或 even variant<attr(a)>。

现在，为什么我不那么感兴趣²。所以，这里是你可以强迫事情的方法。

    foovar_ = bsk::int_ | bsk::double_;
    fooopt_ = (bsk::eps(is_initialized_(bsk::_val)) | '*') << -foovar_;
    start_ = '[' << fooopt_ << ']';

关键是将其编码为替代表达式以外的其他内容。在这里，我们只是相信-foovar_说些什么，或者不说。此外，我们还做

bsk::eps(is_initialized_(bsk::_val)) | '*'

含义：如果变量被初始化，那就是全部，否则，生成'*'。

现在你并不严格需要第三条规则，如果你喜欢只写代码，你可以写：

    start_ = '[' << (bsk::eps(is_initialized_(bsk::_val)) | '*') << -foovar_ << ']';

演示

哦，我差点忘了：

struct is_initialized_f {
    template<typename T>
    bool operator()(boost::optional<T> const& opt) const { return opt.is_initialized(); }
};
boost::phoenix::function<is_initialized_f> is_initialized_;

实现该助手 Phoenix Actor 以检查初始化状态。

Live On Coliru

#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
using FooVariant = boost::variant<int, double>;
using FooOptional = boost::optional<FooVariant>;

template<typename OutputIt = boost::spirit::ostream_iterator>
struct FooGenerator
    : boost::spirit::karma::grammar<OutputIt, FooOptional()>
{
    FooGenerator()
        : FooGenerator::base_type(start_)
    {
        namespace bsk = boost::spirit::karma;
        namespace phx = boost::phoenix;

        foovar_ = bsk::int_ | bsk::double_;
        //fooopt_ = (bsk::eps(is_initialized_(bsk::_val)) | '*') << -foovar_;
        start_ = '[' << (bsk::eps(is_initialized_(bsk::_val)) | '*') << -foovar_ << ']';
    }

  private:
    struct is_initialized_f {
        template<typename T>
        bool operator()(boost::optional<T> const& opt) const { return opt.is_initialized(); }
    };
    boost::phoenix::function<is_initialized_f> is_initialized_;
    boost::spirit::karma::rule<OutputIt, FooVariant()> foovar_;
  //boost::spirit::karma::rule<OutputIt, FooOptional()> fooopt_;
    boost::spirit::karma::rule<OutputIt, FooOptional()> start_;
};

int main()
{
    for (FooOptional fop : { FooOptional{}, {FooVariant{123}}, {FooVariant{3.14}} }) {
        if (std::cout << boost::spirit::karma::format(FooGenerator<>(), fop))
            std::cout << "\n";
        else
        {
            std::cout.clear();
            std::cout << "#Error\n";
        }
    }
}

印刷

[*]
[123]
[3.14]

¹ 笑话

² 我们会得到与“有人忘记”或“这是一种回归”押韵的非权威答案

于 2018-02-08T17:40:49.043 回答