#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_function.hpp>

namespace qi    = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

//
// expression and operator datatypes
// used for parsing the tree
//
struct binary_op;

struct expr_node
{
  typedef boost::variant<double, std::string,
    boost::recursive_wrapper<expr_node>,
    boost::recursive_wrapper<binary_op>,
    boost::recursive_wrapper<std::vector<expr_node> > > type;

  expr_node()
    : type_str("none") {}

  template <typename Expr>
  expr_node(Expr const& expr, const std::string type_str = "none")
    : expr(expr), type_str(type_str) {}

  type expr;
  std::string type_str;
};

struct binary_op
{
  binary_op(const std::string& op, expr_node const& left, expr_node const& right)
  : op(op), left(left), right(right) {}

  std::string op;
  expr_node left;
  expr_node right;
};

struct expr_node_phx
{
  template <typename T, typename U>
  struct result { typedef expr_node type; };

  expr_node operator()(expr_node const& expr, const std::string& type_str) const
  {
    expr_node e(expr.expr,type_str);
    return e;
  }
};

boost::phoenix::function<expr_node_phx> exnd;

struct binary_op_phx
{
  template <typename S, typename T, typename U>
  struct result { typedef T type; };

  expr_node operator()(const std::string& name, expr_node const& expr, expr_node const& rhs) const
  {
    return expr_node(binary_op(name,expr,rhs));
  }
};

boost::phoenix::function<binary_op_phx> biop;

//
//  grammar for parsing expressions
//
template <typename Iterator>
struct Grammar : qi::grammar<Iterator,expr_node(),ascii::space_type>
{
  Grammar() : Grammar::base_type(log_expr)
  {
    using qi::_val;
    using qi::_1;

      log_expr =      log_term  [_val = _1]
      >> *(    '|' >> log_term  [_val = biop("|",_val,_1)]);
    }

    // auto and basic parsers
    qi::rule<Iterator,expr_node()  ,ascii::space_type> log_expr,log_term;
};

std::string parse()
{
  typedef std::string::const_iterator iterator_type;
  Grammar<iterator_type> ixgrammar;
}