Question

Я хочу разобрать цветовые функции CSS (для простоты все аргументы являются числами от 0 до 255)

rgb(r,g,b)
rgba(r,g,b,a)
hsl(h,s,l)
hsla(h,s,l,a)

в

struct color
{
    color(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a) : red{r}, green{g}, blue{b}, alpha{a} {}
    static color hsl(std::uint8_t h, std::uint8_t s, std::uint8_t l, std::uint8_t a) { ... }
    std::uint8_t red;
    std::uint8_t green;
    std::uint8_t blue;
    std::uint8_t alpha;
}

У меня есть рабочий hsl Реализация функции, которая преобразует h, s и l в значения rgb.

У меня также есть rule s для обработки первых двух функций:

constexpr auto uint8 = uint_parser<std::uint8_t>{};
const auto color_rgb = rule<struct rgb, color>{"rgb"}
                     = lit("rgb") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ')' >> attr(255);
const auto color_rgba = rule<struct rgba, color>{"rgba"}
                      = lit("rgba") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ')';

Это работает, потому что у меня естьused

BOOST_FUSION_ADAPT_STRUCT(color,
                          red, green, blue, alpha)

Проблема заключается в функциях hsl.Я не могу сделать секунду BOOST_FUSION_ADAPT_STRUCT, поэтому я подумал об использовании семантических действий с соответствующими последовательностями значений, где семантическое действие просто составило бы color из последовательности.Примерно так:

const auto color_hsl = rule<struct hsl, color, true>{"hsl"}
                   = (lit("hsl") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ')' >> attr(255))[color::hsl];

Это не сработает, иначе я бы не стал задавать этот вопрос.Boost.Spirit.X3 также не имеет что-то в смысле

[ qi::_val = phx::construct<color>(...), qi::_1, qi::_2, qi::_3, qi::_4) ];

Кажется, я хочу сделать вручную то, что делает BOOST_FUSION_ADAPT_STRUCT, но в семантическом действии.Возможно ли это и как мне справиться с этим?Я знаю, что атрибут последовательности должен быть похожим на кортеж "fusion-vector" с четырьмя проанализированными значениями.Я хочу извлечь их и вставить в color::hsl, чтобы сгенерировать атрибут правила.

sehe · Answer 1 · 02 декабря 2018

Здесь применимы многие подсказки.

Я не могу сделать секунду BOOST_FUSION_ADAPT_STRUCT

Конечно, вы можете, см. BOOST_FUSION_ADAPT_STRUCT_NAMED
В Ци эта общая форма, кажется, применима:
```
[ qi::_val = phxfunction(qi::_0) ]
```
Вы можете еще больше упростить это, сделав свой собственный тип актера, чтобы вы могли просто предоставить свой "фабричное действие ": [ factory(&Foo::makeBar) ].

Если вы добавите реализацию fusion::apply ¹, вы можете избежать работы с последовательностью Fusion manuallt
Однако выВозможно, вы захотите узнать об этом - очень хорошо скрытом - режиме совместимости атрибутов для семантических действий: BOOST_SPIRIT_ACTIONS_ALLOW_ATTR_COMPAT.Записано в этот журнал изменений:

Семантические действия теперь поддерживают совместимость атрибутов.Это серьезное изменение, но #define BOOST_SPIRIT_ACTIONS_ALLOW_ATTR_COMPAT должно быть определено, чтобы новое поведение вступило в силу. По умолчанию старое поведение все еще сохраняется .

Вы можете получить желаемое поведение с гораздо меньшими изменениями.

X3 действительно податлив.Мы можем иметь этого factory помощника, описанного выше, всего за:

auto factory = [](auto f) {
    return [f](auto& ctx) {
        x3::_val(ctx) = my_apply(f, x3::_attr(ctx));
    };
};

Я добавлю быстрый набросок my_apply (для boost::fusion::apply, описанного ранее):

namespace detail {
    template <class F, class Sequence, std::size_t... I>
        constexpr decltype(auto) apply_impl(F&& f, Sequence&& t, std::index_sequence<I...>)
        {
            return std::invoke(std::forward<F>(f), boost::fusion::at_c<I>(std::forward<Sequence>(t))...);
        }
}

template <class F, class Sequence>
    constexpr decltype(auto) my_apply(F&& f, Sequence&& t)
    {
        return detail::apply_impl(
                std::forward<F>(f), std::forward<Sequence>(t),
                std::make_index_sequence<typename boost::fusion::result_of::size<std::remove_reference_t<Sequence> >::type{}>{});
    }

Теперь мы можем получить синтаксический анализатор:

namespace parser {
    using namespace x3;

    constexpr auto uint8  = uint_parser<std::uint8_t>{};

    auto factory = [](auto f) {
        return [f](auto& ctx) {
            x3::_val(ctx) = my_apply(f, x3::_attr(ctx));
        };
    };

    const auto color_rgb  = rule<struct rgb, ast::color>{"rgb"}
                          = lit("rgb") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> x3::attr(255u) >> ')';
    const auto color_rgba = rule<struct rgba, ast::color>{"rgba"}
                          = lit("rgba") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ')';
    const auto color_hsl  = rule<struct hsl, ast::color>{"hsl"}
                          = (lit("hsl") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> attr(255u) >> ')') [factory(ast::color::hsl)];

    const auto color = skip(space) [ color_rgba | color_rgb | color_hsl ];
}

и протестировать его с помощью:

int main() {
    for (std::string const input : {
            "rgb(1,2,3)",
            "rgba(4,5,6,7)",
            "hsl(8,9,10)" }) 
    {
        std::cout << " ----- Parsng " << std::quoted(input) << " --------\n";
        auto begin = input.begin(), end = input.end();

        ast::color result;
        bool success = parse(begin, end, parser::color, result);

        if (success) {
            std::cout << "parsed: ";
            std::cout << result << "\n";
        } else {
            std::cout << "failed\n";
        }

        if (begin != end) {
            std::cout << "Remaining unparsed: " << std::quoted(std::string(begin, end)) << std::endl;
        }
    }
}

Отпечатки:

Live On Coliru

 ----- Parsng "rgb(1,2,3)" --------
parsed: rgba(1,2,3,255)
 ----- Parsng "rgba(4,5,6,7)" --------
parsed: rgba(4,5,6,7)
 ----- Parsng "hsl(8,9,10)" --------
TODO: implement static ast::color ast::color::hsl(uint8_t, uint8_t, uint8_t, uint8_t)(8,9,10,255)
parsed: rgba(8,9,10,255)

Полный список

Live On Coliru

#include <iostream>
#include <iomanip>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/adapted/struct.hpp>
#include <boost/fusion/include/size.hpp>

namespace x3 = boost::spirit::x3;


namespace ast {
    using std::uint8_t;

    struct color {
        uint8_t red, green, blue, alpha;

        color(uint8_t r=0, uint8_t g=0, uint8_t b=0, uint8_t a=255) : red{r}, green{g}, blue{b}, alpha{a} {}

        static color hsl(uint8_t h, uint8_t s, uint8_t l, uint8_t a) { 
            std::cerr << "TODO: implement " << __PRETTY_FUNCTION__ << "(" << 1*h << "," << 1*s << "," << 1*l << "," << 1*a << ")\n";
            return {h,s,l,a}; }
    };

    static inline std::ostream& operator<<(std::ostream& os, color const& c) {
        return os << "rgba(" << 1*c.red << "," << 1*c.green << "," << 1*c.blue << "," << 1*c.alpha << ")";
    }
}

BOOST_FUSION_ADAPT_STRUCT(ast::color, red, green, blue, alpha);

namespace {
    namespace detail {
        template <class F, class Sequence, std::size_t... I>
            constexpr decltype(auto) apply_impl(F&& f, Sequence&& t, std::index_sequence<I...>)
            {
                return std::invoke(std::forward<F>(f), boost::fusion::at_c<I>(std::forward<Sequence>(t))...);
            }
    }

    template <class F, class Sequence>
        constexpr decltype(auto) my_apply(F&& f, Sequence&& t)
        {
            return detail::apply_impl(
                    std::forward<F>(f), std::forward<Sequence>(t),
                    std::make_index_sequence<typename boost::fusion::result_of::size<std::remove_reference_t<Sequence> >::type{}>{});
        }
}

namespace parser {
    using namespace x3;

    constexpr auto uint8  = uint_parser<std::uint8_t>{};

    auto factory = [](auto f) {
        return [f](auto& ctx) {
            x3::_val(ctx) = my_apply(f, x3::_attr(ctx));
        };
    };

    const auto color_rgb  = rule<struct rgb, ast::color>{"rgb"}
                          = lit("rgb") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> x3::attr(255u) >> ')';
    const auto color_rgba = rule<struct rgba, ast::color>{"rgba"}
                          = lit("rgba") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> ')';
    const auto color_hsl  = rule<struct hsl, ast::color>{"hsl"}
                          = (lit("hsl") >> '(' >> uint8 >> ',' >> uint8 >> ',' >> uint8 >> attr(255u) >> ')') [factory(ast::color::hsl)];

    const auto color = skip(space) [ color_rgba | color_rgb | color_hsl ];
} 

int main() {
    for (std::string const input : {
            "rgb(1,2,3)",
            "rgba(4,5,6,7)",
            "hsl(8,9,10)" }) 
    {
        std::cout << " ----- Parsng " << std::quoted(input) << " --------\n";
        auto begin = input.begin(), end = input.end();

        ast::color result;
        bool success = parse(begin, end, parser::color, result);

        if (success) {
            std::cout << "parsed: ";
            std::cout << result << "\n";
        } else {
            std::cout << "failed\n";
        }

        if (begin != end) {
            std::cout << "Remaining unparsed: " << std::quoted(std::string(begin, end)) << std::endl;
        }
    }
}

seems, кажется, не существует.Конечно, вы можете скопировать в std::tuple и использовать std::apply (также экспериментальный )

Передача каждого элемента анализируемой последовательности в функцию, которая возвращает тип атрибута правила

Пожалуйста, войдите или зарегистрируйтесь чтобы ответить на этот вопрос.

1 Ответ

Полный список

Пожалуйста, войдите или зарегистрируйтесь что бы добавить комментарий.

Передача каждого элемента анализируемой последовательности в функцию, которая возвращает тип атрибута правила

Пожалуйста, войдите или зарегистрируйтесь чтобы ответить на этот вопрос.

1 Ответ

Полный список

Пожалуйста, войдите или зарегистрируйтесь что бы добавить комментарий.

Похожие темы