LogicExpression.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrigConf_LogicExpression
#define TrigConf_LogicExpression
 
#include <iostream>
#include <string>
#include <vector>
#include <memory>
 
namespace TrigConf {
 
   class LogicExpression;
   typedef std::vector<std::shared_ptr<LogicExpression>> LogicV_t;
 
   class LogicExpression {
   public:
 
      // The following 5 symbols represent the possible states of 
      // a logic expression.
      static const char kAND     = '&'; 
      static const char kOR      = '|'; 
      static const char kNOT     = '!'; 
      static const char kELEMENT = '#'; 
      static const char kOPEN    = '('; 
      static const char kCLOSE   = ')'; 
 
      static bool isValidElementChar(char c);
      static std::string extractElementName(const std::string& expr);
 
   public:
      LogicExpression(std::ostream & o = std::cout);
 
      virtual ~LogicExpression() = default;
 
      LogicExpression(const std::string& name, std::ostream & o = std::cout);
 
      virtual int parse(const std::string& expr, bool enclosed=false);
      virtual std::string logicRep() const;
 
      void setState(char s) { m_State = s; }
      void setElement(const std::string& e) { m_Element = e; }
      void addSubLogic(const LogicExpression& sub) {
         m_SubLogics.emplace_back(std::make_shared<LogicExpression>(sub));
      }
 
      char                    state()         const { return m_State; }
      const std::string&      element()       const { return m_Element; }
      const LogicV_t &        subLogics()     const { return m_SubLogics; }
      const std::shared_ptr<LogicExpression> subLogic(int i) const { return subLogics()[i]; }
      bool                    isPlaceHolder() const { return (m_State==kOPEN && m_SubLogics.size()==1); }
 
 
      //LogicV_t&        LogicExpression::subLogics() { return m_SubLogics; }
 
      int totalNumberOfElements() const;
 
      void markPlaceHolder();
      void normalize();
      void printError(const std::string& message, int i);
      void printCurrentState();
      void print(const std::string& indent="");
      void clear();
 
   protected:
 
      std::string m_LogicRep;
 
      char m_State;
 
      LogicV_t m_SubLogics;
      std::string m_Element;
 
      std::ostream & m_ostream; 
 
   };
 
}
 
#endif // TrigConf_LogicExpression