Check parsed values before they are assigned to the variable

[Omar-Medina]

Hello everyone,
First . Thanks very much for the library Spirit.

I would like to know if it is possible with Qi-Spirit to check the successfully parsed values before assigning them to the target list of variable/struct.

Example:
the following values "3 , 5 ; 6 , 7; 9 , 6; 6 , 8; 3 , 5" shall be assigned to a vector<2values>.

The pair of values shall only be assigned and stored into the vector<2values>, only if the first value is less than second value. And the pair of values does not exist in the vector <2values>

After parsing the vector<2value> shall contain { {3 , 5}, {6 , 7} , { 6 , 8} }. The pair "9 , 6" does not satisfy the condition and "3,5" already exist .

hier my solution, but it is not generic.

Thanks in advance for some ideas

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>
#include <iostream>
using namespace boost::spirit;

struct vMinMaxValue
{
    int valuMin;
    int valuMax;
};

BOOST_FUSION_ADAPT_STRUCT(
    vMinMaxValue,
  (int, valuMin)
  (int, valuMax)
)

template <typename T>
class myVectoc
{
public:
    typedef T value_type;
    typedef typename std::vector<T>::iterator iterator;
    typedef typename std::vector<T>::const_iterator const_iterator;

    std::vector<T> mv;
public:
    iterator insert(iterator p, const value_type& x)
    {
      bool found = false;

      for (const T &elem : mv)
      {
        if (
            (elem.valuMin == x.valuMin) &&
            (elem.valuMax == x.valuMax)
           )
        {
          found = true;
          break;
        }
      }

      if (
          (found == false) &&
          (x.valuMin < x.valuMax)
         )
      {

        return mv.insert(p,x);
      }
      else
      {
        return p;
      }
    }

    iterator end()
    {
      return mv.end();
    }
};

struct vMinMaxLstValues
{
    vMinMaxValue first;
    myVectoc<vMinMaxValue> others;
};


BOOST_FUSION_ADAPT_STRUCT(
    vMinMaxLstValues,
  (vMinMaxValue, first)
  (myVectoc<vMinMaxValue>, others)
)

template <typename Iterator, typename Skipper>
struct my_grammar : qi::grammar<Iterator, vMinMaxLstValues(),Skipper>
{
  my_grammar() : my_grammar::base_type{values}
  {
    minV = qi::no_case[qi::lit("0x")] >> qi::uint_parser<int,16>();
    maxV = qi::no_case[qi::lit("0x")] >> qi::uint_parser<int,16>();
    value  = minV >> -( qi::lit(',') )  >>  maxV;
    values = value >> ';' >> value % ';';
  }

  qi::rule<Iterator, int()> minV;
  qi::rule<Iterator, int()> maxV;
  qi::rule<Iterator, vMinMaxValue(), Skipper> value;
  qi::rule<Iterator, vMinMaxLstValues(), Skipper> values;
};

int main()
{
  std::string s;
  std::getline(std::cin, s);

  auto it = s.begin();
  my_grammar<std::string::iterator, ascii::space_type> g;
  vMinMaxLstValues v;
  if (qi::phrase_parse(it, s.end(), g, ascii::space, v))
  {
    std::cout <<   "valueMin=\"" << boost::lexical_cast<std::string>(v.first.valuMin) << "\" "
              <<   "valueMax=\"" << boost::lexical_cast<std::string>(v.first.valuMax) << "\" "
              << std::endl;
    for (const auto &elem : v.others.mv)
    {
      std::cout <<   "valueMin=\"" << boost::lexical_cast<std::string>(elem.valuMin) << "\" "
                <<   "valueMax=\"" << boost::lexical_cast<std::string>(elem.valuMax) << "\" "
                << std::endl;

    }
  }
  else
  {

  }
  return 0;
}

output:

Appl_dbg.exe
0x3 , 0x5 ; 0x6 , 0x7; 0x9 , 0x6; 0x6 , 0x8; 0x3 , 0x5; 0x6 , 0x07
valueMin="3" valueMax="5"
valueMin="6" valueMax="7"
valueMin="6" valueMax="8"
valueMin="3" valueMax="5"

the first pair 0x3 and ox05 does not belong to the vector

Example.zip

[Omar-Medina]

Hello everyone,
I am sorry for the question. I think , i found the solution in the documentation "Store a Parsed Attribute Value into a Container (Qi)". The solution may be (See below). If you have other suggestion to do it more generic. Please lead me know

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/spirit/home/support/container.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>
#include <iostream>

using namespace boost::spirit;

struct vMinMaxValue
{
    int valuMin;
    int valuMax;
};

BOOST_FUSION_ADAPT_STRUCT(
    vMinMaxValue,
  (int, valuMin)
  (int, valuMax)
)

namespace boost { namespace spirit { namespace traits
{
  template <>
  struct push_back_container<std::vector<vMinMaxValue>, vMinMaxValue>
  {
    static bool call(std::vector<vMinMaxValue> &c, vMinMaxValue const& val)
    {
      bool found = false;
      for (const vMinMaxValue &elem : c)
      {
        if (
             (elem.valuMin == val.valuMin) &&
             (elem.valuMax == val.valuMax)
           )
        {
          found = true;
          break;
        }
      }
      if (
           (found == false) &&
           (val.valuMin < val.valuMax)
         )
      {
        c.push_back(val);
      }
      return true;
    }
  };

}}}


template <typename Iterator, typename Skipper>
struct my_grammar : qi::grammar<Iterator, std::vector<vMinMaxValue>(),Skipper>
{
  my_grammar() : my_grammar::base_type{values}
  {
    mxnV = qi::no_case[qi::lit("0x")] >> qi::uint_parser<int,16>();
    value  = mxnV >> -( qi::lit(',') )  >>  mxnV;
    values = value % ';';
  }

  qi::rule<Iterator, int()> mxnV;
  qi::rule<Iterator, vMinMaxValue(), Skipper> value;
  qi::rule<Iterator, std::vector<vMinMaxValue>(), Skipper> values;
};

int main()
{
  std::string s;
  std::getline(std::cin, s);

  auto it = s.begin();
  my_grammar<std::string::iterator, ascii::space_type> g;
  std::vector<vMinMaxValue> v;
  if (qi::phrase_parse(it, s.end(), g, ascii::space, v))
  {
    for (const auto &elem : v)
    {
      std::cout <<   "valueMin=\"" << boost::lexical_cast<std::string>(elem.valuMin) << "\" "
                <<   "valueMax=\"" << boost::lexical_cast<std::string>(elem.valuMax) << "\" "
                << std::endl;
    }
  }
  else
  {

  }
  return 0;
}

Output:

>>Appl_dbg.exe
0x3 0x5;0x6,0x9; 0x5 0x2 ; 0xaa, 0xbb; 0x6 , 0x9 ; 0x0 , 0x1
valueMin="3" valueMax="5"
valueMin="6" valueMax="9"
valueMin="170" valueMax="187"
valueMin="0" valueMax="1"

Example.zip

[Kojoley]

You may want to use set-like container if you need to preserve only unique values, and validation could be done via semantic actions:

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <compare>
#include <string>
#include <set>
#include <iostream>

using namespace boost::spirit;

struct vMinMaxValue
{
  int valuMin;
  int valuMax;

  auto operator<=>(vMinMaxValue const&) const = default;
};

BOOST_FUSION_ADAPT_STRUCT(
  vMinMaxValue,
  (int, valuMin)
  (int, valuMax)
)

template <typename Iterator, typename Skipper>
struct my_grammar : qi::grammar<Iterator, std::set<vMinMaxValue>(),Skipper>
{
  my_grammar() : my_grammar::base_type{values}
  {
    mxnV = qi::no_case[qi::lit("0x")] >> qi::uint_parser<int,16>();
    value %= mxnV >> -qi::lit(',') >> mxnV[([](unused_type, auto const& ctx, bool& pass) {
      vMinMaxValue const& val = boost::fusion::at_c<0>(ctx.attributes);
      pass = val.valuMin < val.valuMax;
    })];
    values = value % ';';
  }

  qi::rule<Iterator, int()> mxnV;
  qi::rule<Iterator, vMinMaxValue(), Skipper> value;
  qi::rule<Iterator, std::set<vMinMaxValue>(), Skipper> values;
};

int main()
{
  std::string s;
  std::getline(std::cin, s);

  auto it = s.begin();
  my_grammar<std::string::iterator, ascii::space_type> g;
  std::set<vMinMaxValue> v;
  if (qi::phrase_parse(it, s.end(), g, ascii::space, v) && it == s.end())
  {
    for (const auto &elem : v)
    {
      std::cout <<   "valueMin=\"" << elem.valuMin << "\" "
                <<   "valueMax=\"" << elem.valuMax << "\" "
                << std::endl;
    }
  }
  else
  {
      std::cout << "parsing stopped at '" << std::string(it, s.end()) << "'\n";
  }
}

[Omar-Medina]

Thanks very much.
Note for other people: The suggestion above is compileable with c++20