For what it's worth, the following hack makes boost::spirit work with std::variant:

#include <variant>

#include <boost/spirit/home/karma/operator/alternative.hpp>
#include <boost/spirit/home/qi/operator/alternative.hpp>
#include <boost/spirit/home/support/attributes.hpp>

namespace boost {
	namespace spirit {
		namespace traits {
			template <typename... Ts, typename Domain>
			struct not_is_variant<std::variant<Ts...>, Domain> : boost::mpl::false_
			{
			};
			template <typename... Ts, typename Expected>
			struct compute_compatible_component_variant<std::variant<Ts...>, Expected, mpl::false_>
			{
				using types = boost::mpl::vector<Ts...>;
				using end = typename mpl::end<types>::type;
				using iter = typename mpl::find_if<types, is_same<Expected, mpl::_1>>::type;
				using distance = typename mpl::distance<typename mpl::begin<types>::type, iter>::type;
				using type = typename mpl::not_<is_same<iter, end>>::type;
				enum { value = type::value };
				using compatible_type = typename mpl::eval_if<type, mpl::deref<iter>, mpl::identity<unused_type>>::type;
				constexpr static bool is_compatible(int which) { return which == distance::value; }
			};

			template <typename... Ts>
			struct variant_which<std::variant<Ts...>>
			{
				static int call(std::variant<Ts...> const & v) { return static_cast<int>(v.index()); }
			};
			struct VariantAttributeSizeVisitior
			{
				template <typename T>
				std::size_t operator()(T const & val) const
				{
					return spirit::traits::size(val);
				}
			};
			template <typename... Ts>
			struct attribute_size<std::variant<Ts...>>
			{
				using type = std::size_t;
				static type call(std::variant<Ts...> const & val) { return std::visit(VariantAttributeSizeVisitior(), val); }
			};
		} // namespace traits
		namespace qi {
			namespace detail {
				template <typename Expected, typename... Ts>
				struct find_substitute<std::variant<Ts...>, Expected>
				{
					using types = mpl::vector<Ts...>;
					using end = typename mpl::end<types>::type;
					using iter_1 = typename mpl::find_if<types, is_same<mpl::_1, Expected>>::type;
					using iter = typename mpl::eval_if<is_same<iter_1, end>, mpl::find_if<types, traits::is_substitute<mpl::_1, Expected>>, mpl::identity<iter_1>>::type;
					using type = typename mpl::eval_if<is_same<iter, end>, mpl::identity<Expected>, mpl::deref<iter>>::type;
				};
			} // namespace detail
		}         // namespace qi
		namespace karma {
			namespace detail {
				template <typename Component, typename Expected, typename... Ts>
				struct alternative_generate<Component,
				                            std::variant<Ts...>,
				                            Expected,
				                            typename enable_if<traits::compute_compatible_component<Expected, std::variant<Ts...>, karma::domain>>::type>
				{
					using Attribute = std::variant<Ts...>;
					template <typename OutputIterator, typename Context, typename Delimiter>
					static bool call(Component const & component, OutputIterator & sink, Context & ctx, Delimiter const & d, Attribute const & attr, bool &)
					{
						return call(component, sink, ctx, d, attr, spirit::traits::not_is_variant<Attribute, karma::domain>());
					}
					template <typename OutputIterator, typename Context, typename Delimiter>
					static bool call(Component const & component, OutputIterator & sink, Context & ctx, Delimiter const & d, Attribute const & attr, mpl::true_)
					{
						return component.generate(sink, ctx, d, attr);
					}
					template <typename OutputIterator, typename Context, typename Delimiter>
					static bool call(Component const & component, OutputIterator & sink, Context & ctx, Delimiter const & d, Attribute const & attr, mpl::false_)
					{
						using component_type = traits::compute_compatible_component<Expected, Attribute, domain>;
						if (!traits::has_optional_value(attr))
							return false;
						typename traits::optional_attribute<Attribute>::type attr_ = traits::optional_value(attr);
						if (!component_type::is_compatible(spirit::traits::which(attr_)))
							return false;
						typedef typename component_type::compatible_type compatible_type;
						return component.generate(sink, ctx, d, std::get<compatible_type>(attr_));
					}
				};
			} // namespace detail
		}         // namespace karma
	}                 // namespace spirit
} // namespace boost

It also shows that adding support for std::variant is very much straight forward. The same is probably true for std::optional.

Add support for std::optional #15

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions