CP::SelectionExprParser Class Reference

Public interface for the expression parsing facility. More...

#include <SelectionExprParser.h>

Collaboration diagram for CP::SelectionExprParser:

Public Member Functions
	SelectionExprParser (DetailSelectionExprParser::Lexer lexer, bool defaultToChar=false)
	Constructor for the parser which accepts a Lecer.
StatusCode	build (std::unique_ptr< ISelectionReadAccessor > &accessor)
	Triggers the actual parsing of the expression.

Private Member Functions
StatusCode	expression (std::unique_ptr< ISelectionReadAccessor > &root)
StatusCode	term (std::unique_ptr< ISelectionReadAccessor > &root)
StatusCode	factor (std::unique_ptr< ISelectionReadAccessor > &root)

Private Attributes
DetailSelectionExprParser::Lexer	m_lexer
DetailSelectionExprParser::Lexer::Symbol	m_symbol {}
bool	m_defaultToChar {}

Detailed Description

Public interface for the expression parsing facility.

Definition at line 80 of file SelectionExprParser.h.

Constructor & Destructor Documentation

SelectionExprParser()

CP::SelectionExprParser::SelectionExprParser	(	DetailSelectionExprParser::Lexer	lexer,
		bool	defaultToChar = false )

Constructor for the parser which accepts a Lecer.

Parameters

lexer

The lexer to use for parsing

Note

Lexer can be auto-constructed from a string, so you can pass one directly.

Parameters

defaultToChar

Assume "as_char" as default encoding

Definition at line 90 of file SelectionExprParser.cxx.

    : m_lexer(std::move(lexer)), m_defaultToChar(defaultToChar) {}

Member Function Documentation

build()

StatusCode CP::SelectionExprParser::build

(

std::unique_ptr< ISelectionReadAccessor > &

accessor

)

Triggers the actual parsing of the expression.

Parameters

[out]

accessor

Unique pointer the resulting accessor will be written to.

Returns

StatusCode noting whether the operation succeeded.

Definition at line 93 of file SelectionExprParser.cxx.

                                                     {
  std::unique_ptr<ISelectionReadAccessor> root{nullptr};
  ANA_CHECK(expression(root));
 
  if (m_symbol.type != Lexer::END) {
    throw std::runtime_error(
        "Not all symbols in expression were consumed. Check your expression.");
  }
 
  accessor = std::move(root);
  return StatusCode::SUCCESS;
}

expression()

StatusCode CP::SelectionExprParser::expression ( std::unique_ptr< ISelectionReadAccessor > & root )

private

Definition at line 107 of file SelectionExprParser.cxx.

                                                 {
  ANA_CHECK(term(root));
  while (m_symbol.type == Lexer::OR) {
    std::unique_ptr<ISelectionReadAccessor> left = std::move(root);
    ANA_CHECK(term(root));
    std::unique_ptr<ISelectionReadAccessor> right = std::move(root);
    root = std::make_unique<SelectionAccessorExprOr>(std::move(left),
                                                     std::move(right));
  }
  return StatusCode::SUCCESS;
}

factor()

StatusCode CP::SelectionExprParser::factor ( std::unique_ptr< ISelectionReadAccessor > & root )

private

Definition at line 139 of file SelectionExprParser.cxx.

                                                 {
  m_symbol = m_lexer.nextSymbol();
  if (m_symbol.type == Lexer::TRUE_LITERAL) {
    root = std::make_unique<SelectionReadAccessorNull>(true);
    m_symbol = m_lexer.nextSymbol();
  } else if (m_symbol.type == Lexer::FALSE_LITERAL) {
    root = std::make_unique<SelectionReadAccessorNull>(false);
    m_symbol = m_lexer.nextSymbol();
  } else if (m_symbol.type == Lexer::NOT) {
    ANA_CHECK(factor(root));
    std::unique_ptr<ISelectionReadAccessor> notEx =
        std::make_unique<SelectionAccessorExprNot>(std::move(root));
    root = std::move(notEx);
  } else if (m_symbol.type == Lexer::LEFT) {
    ANA_CHECK(expression(root));
    if (m_symbol.type != Lexer::RIGHT) {
      throw std::runtime_error(
          "Missing closing bracket, check your expression.");
    }
    m_symbol = m_lexer.nextSymbol();
 
  } else if (m_symbol.type == Lexer::VAR) {
    ANA_CHECK(makeSelectionReadAccessorVar(m_symbol.value, root, m_defaultToChar));
    m_symbol = m_lexer.nextSymbol();
  } else {
    throw std::runtime_error("Malformed expression.");
  }
 
  return StatusCode::SUCCESS;
}

term()

StatusCode CP::SelectionExprParser::term ( std::unique_ptr< ISelectionReadAccessor > & root )

private

Definition at line 120 of file SelectionExprParser.cxx.

                                                 {
  ANA_CHECK(factor(root));
  std::vector<std::unique_ptr<ISelectionReadAccessor>> factors;
  factors.push_back(std::move(root));
 
  while (m_symbol.type == Lexer::AND) {
    ANA_CHECK(factor(root));
    factors.push_back(std::move(root));
  }
 
  if (factors.size() == 1) {
    root = std::move(factors[0]);
  } else {
    root = std::make_unique<SelectionAccessorList>(std::move(factors));
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_defaultToChar

bool CP::SelectionExprParser::m_defaultToChar {}

private

Definition at line 107 of file SelectionExprParser.h.

{};

m_lexer

DetailSelectionExprParser::Lexer CP::SelectionExprParser::m_lexer

private

Definition at line 103 of file SelectionExprParser.h.

m_symbol

DetailSelectionExprParser::Lexer::Symbol CP::SelectionExprParser::m_symbol {}

private

Definition at line 105 of file SelectionExprParser.h.

{};

---

The documentation for this class was generated from the following files:

• SelectionExprParser.h
• SelectionExprParser.cxx