Boost Spirit Karma - Output vector of strings with constraints and propagate failure?

Question

I want to output a vector of strings using Boost Spirit Karma. The output generation should fail if any of the strings don't satisfy the constraints. I have tried the following:

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

namespace ka = boost::spirit::karma;

int main()
{
    typedef std::ostream_iterator<char> iterator_t;

    std::string is1{"123"}, is2{"def"};
    std::vector<std::string> iv1{"123", "456"}, iv2{"123","def"};

    auto num = +ka::char_("0-9");
    auto nums = num % ka::lit(";");

    assert(ka::generate(iterator_t{std::cout}, num << ka::eol, is1) == true);
    assert(ka::generate(iterator_t{std::cout}, num << ka::eol, is2) == false);

    assert(ka::generate(iterator_t{std::cout}, nums << ka::eol, iv1) == true);
    assert(ka::generate(iterator_t{std::cout}, nums << ka::eol, iv2) == false); // Assertion Fails
}

Is there a way to make the rule fail if any of the sub-rules do not succeed?

Answer 1

Here is one posible solution that creates a custom directive (heavily based on the one explained here, full code) called full that only returns true when its subject returns true and the number of elements generated is equal to the number of elements in the container passed as attribute.

The changes I've made are:

• replaced columns_delimiter with element_counter_delimiter.
• replaced simple_columns_generator with full_container_generator.
• replaced columns with full.
• deleted the member function final_delimit_out.
• modified slightly generate in element_counter_delimiter and full_container_generator.
• added adjust_size in order to account for the fact that % generates 2*num_elem - 1 times (n ints and n-1 semicolons)

---

Live Example

#include <iostream>
#include <boost/spirit/include/karma.hpp>

//START OF FULL.HPP
#include <boost/spirit/include/karma_generate.hpp>

///////////////////////////////////////////////////////////////////////////////
// definition the place holder 
namespace custom_generator 
{ 
    BOOST_SPIRIT_TERMINAL(full);
} 

///////////////////////////////////////////////////////////////////////////////
// implementation the enabler
namespace boost { namespace spirit 
{ 
    // We want custom_generator::full to be usable as a directive only, 
    // and only for generator expressions (karma::domain).
    template <>
    struct use_directive<karma::domain, custom_generator::tag::full> 
      : mpl::true_ {}; 
}}

///////////////////////////////////////////////////////////////////////////////
// implementation of the generator
namespace custom_generator
{ 
    template <typename T>
    struct adjust_size
    {
        static std::size_t call(std::size_t val)
        {
            return val; //with kleene and repeat just return the value
        }
    };

    template <typename Left, typename Right>
    struct adjust_size<boost::spirit::karma::list<Left,Right> >
    {
        static std::size_t call(std::size_t val)
        {
            return (val+1)/2; //with list you output n elements and n-1 semicolons
        }
    };
    // special delimiter wrapping the original one that counts the number of elements
    template <typename Delimiter>
    struct element_counter_delimiter 
    {
        element_counter_delimiter(Delimiter const& delim)
          : delimiter(delim), count(0) {}

        // This function is called during the actual delimiter output 
        template <typename OutputIterator, typename Context
          , typename Delimiter_, typename Attribute>
        bool generate(OutputIterator& sink, Context&, Delimiter_ const&
          , Attribute const&) const
        {
            // first invoke the wrapped delimiter
            if (!boost::spirit::karma::delimit_out(sink, delimiter))
                return false;

            // now we count the number of invocations 
            ++count;

            return true;
        }

        Delimiter const& delimiter;   // wrapped delimiter
        mutable unsigned int count;   // invocation counter
    };

    // That's the actual full generator
    template <typename Subject>
    struct full_container_generator
      : boost::spirit::karma::unary_generator<
            full_container_generator<Subject> >
    {
        // Define required output iterator properties
        typedef typename Subject::properties properties;

        // Define the attribute type exposed by this parser component
        template <typename Context, typename Iterator>
        struct attribute 
          : boost::spirit::traits::attribute_of<Subject, Context, Iterator> 
        {};

        full_container_generator(Subject const& s)
          : subject(s)
        {}

        // This function is called during the actual output generation process.
        // It dispatches to the embedded generator while supplying a new 
        // delimiter to use, wrapping the outer delimiter.
        template <typename OutputIterator, typename Context
          , typename Delimiter, typename Attribute>
        bool generate(OutputIterator& sink, Context& ctx
          , Delimiter const& delimiter, Attribute const& attr) const
        {
            std::size_t elems_in_container = boost::spirit::traits::size(attr);
            element_counter_delimiter<Delimiter> d(delimiter);
            if (!subject.generate(sink, ctx, d, attr))
                return false;
            return elems_in_container == adjust_size<Subject>::call(d.count);
        }

        // This function is called during error handling to create
        // a human readable string for the error context.
        template <typename Context>
        boost::spirit::info what(Context& ctx) const
        {
            return boost::spirit::info("full", subject.what(ctx));
        }

        Subject subject;
    };
}

///////////////////////////////////////////////////////////////////////////////
// instantiation of the generator
namespace boost { namespace spirit { namespace karma
{
    // This is the factory function object invoked in order to create 
    // an instance of our full_container_generator.
    template <typename Subject, typename Modifiers>
    struct make_directive<custom_generator::tag::full, Subject, Modifiers>
    {
        typedef custom_generator::full_container_generator<Subject> result_type;

        result_type operator()(unused_type, Subject const& s, unused_type) const
        {
            return result_type(s);
        }
    };
}}}

//END OF FULL.HPP


int main()
{
    typedef std::ostream_iterator<char> iterator_t;
    namespace ka=boost::spirit::karma;

    std::string is1{"123"}, is2{"def"};
    std::vector<std::string> iv1{"123", "456"}, iv2{"123","def"}, iv3{"123", "456", "789"}, iv4{"123", "456", "def"};

    using custom_generator::full;

    ka::rule<iterator_t,std::string()> num = +ka::char_("0-9"); //this rule needs to have attribute std::string
                                                                //that wasn't the case with the original "auto num =..."
                                                                //and it caused that the delimiter count went way higher than it should
    ka::rule<iterator_t,std::vector<std::string>()> nums = full[num%ka::lit(";")];


    assert(ka::generate(iterator_t{std::cout}, num << ka::eol, is1) == true);
    assert(ka::generate(iterator_t{std::cout}, num << ka::eol, is2) == false);

    assert(ka::generate(iterator_t{std::cout}, nums << ka::eol, iv1) == true);
    assert(ka::generate(iterator_t{std::cout}, ka::buffer[nums << ka::eol], iv2) == false); //using buffer as mentioned by sehe
    assert(ka::generate(iterator_t{std::cout}, nums << ka::eol, iv3) == true);
    assert(ka::generate(iterator_t{std::cout}, ka::buffer[nums << ka::eol], iv4) == false);
}

Answer 2

I don't know what version of boost you use, but

• 1_42_0 doesn't compile your snippet

• 1_49_0 doesn't fail and prints:

  123
  123;456
  

• 1_54_0 doesn't fail and prints:

  123
  123;456
  

So, I can't reproduce the problem. However, conceptually, I think you are looking for karma::buffer[]:

Generator Directive for Temporary Output Buffering (buffer[])

All generator components (except the Alternative (|) generator) pass their generated output directly to the underlying output stream. If a generator fails halfway through, the output generated so far is not 'rolled back'. The buffering generator directive allows to avoid this unwanted output to be generated. It temporarily redirects the output produced by the embedded generator into a buffer. This buffer is flushed to the underlying stream only after the embedded generator succeeded, but is discarded otherwise.

So you could add

ka::rule<iterator_t, std::string()>              num  = +ka::char_("0-9");
ka::rule<iterator_t, std::vector<std::string>()> nums = ka::buffer [ num % ka::lit(";") ];

---

Note I wouldn't rule out that you were looking at Undefined Behaviour because Proto expression trees don't mix well with auto because of stale references to temporaries in the sub-expressions.