ExpressionParser.hpp

// <ExpressionParser> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <sstream>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/statistics/StatisticInstance.hpp"
 
#include "sparta/statistics/Expression.hpp"
#include "sparta/statistics/ExpressionNodeVariables.hpp"
#include "sparta/statistics/ExpressionGrammar.hpp"
 
#include <memory>
#include <stack>
 
namespace sparta {
    namespace statistics {
        namespace expression {
 
class ExpressionParser
{
    Expression parse_temp_;
 
    const grammar::ExpressionGrammar grammar_;
 
public:
 
    ExpressionParser(TreeNode* n,
                     std::vector<const TreeNode*>& already_used,
                     const StatisticPairs &report_si) :
        grammar_(n, already_used, report_si)
    { }
 
    Expression&& parse(const std::string& input) {
        using boost::spirit::ascii::space;
 
        std::string::const_iterator iter = input.begin();
        std::string::const_iterator end  = input.end();
        bool r = qi::phrase_parse(iter, end, grammar_, space, parse_temp_);
 
        if (!r || iter != end){
            throw SpartaException("Parsing expression \"") << input << "\" failed to parse remainder"
                << " \"" << std::string(iter, end) << "\". Note that this does not indicate which "
                "part of the expression was wrong, but how much the recursive parser could "
                "properly interpret";
        }
 
        return std::move(parse_temp_);
    }
};
 
        } // namespace expression
    } // namespace statistics
} // namespace sparta