tempest/resources/3rdparty/cpphoafparser-0.99.2/include/cpphoafparser/ast/boolean_expression.hh

//==============================================================================
//
//  Copyright (c) 2015-
//  Authors:
//  * Joachim Klein <klein@tcs.inf.tu-dresden.de>
//  * David Mueller <david.mueller@tcs.inf.tu-dresden.de>
//
//------------------------------------------------------------------------------
//
//  This file is part of the cpphoafparser library,
//      http://automata.tools/hoa/cpphoafparser/
//
//  The cpphoafparser library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  The cpphoafparser library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
//==============================================================================

#ifndef CPPHOAFPARSER_BOOLEANEXPRESSION_H
#define CPPHOAFPARSER_BOOLEANEXPRESSION_H

#include <memory>
#include <iostream>
#include <sstream>
#include <stdexcept>

namespace cpphoafparser {

/**
 * This represents (a node of) an abstract syntax tree
 * of a boolean expression, parametrized with the type
 * of leaf nodes (atoms).
 *
 * The nodes are designed to be immutable, which allows
 * sharing of subexpression in a safe way between multiple
 * trees.
 *
 * For unary operator (NOT), the child is stored as the
 * left child of the not.
 *
 * With AtomLabel, this represents a label expression
 * over atomic propositions, with AtomAcceptance an
 * expression of Fin/Inf acceptance conditions.
 *
 * @tparam <Atoms> The atoms (leaf nodes) in the abstract syntax tree.
 */
template <typename Atoms>
class BooleanExpression {
public:
  /** A shared_ptr to a node in this AST */
  typedef std::shared_ptr< BooleanExpression<Atoms> > ptr;
  /** A shared_ptr to an atom (leaf node) in this AST */
  typedef std::shared_ptr< Atoms> atom_ptr;

  /** The node types of this AST */
  enum OperatorType {
    EXP_AND,
    EXP_OR,
    EXP_NOT,
    EXP_TRUE,
    EXP_FALSE,
    EXP_ATOM
  };

  /** Get the node type for this node */
  OperatorType getType() {
    return kind;
  }

  /** Static constructor for a node representing a TRUE leaf */
  static ptr True() {return ptr(new BooleanExpression(true));}
  /** Static constructor for a node representing a FALSE leaf */
  static ptr False() {return ptr(new BooleanExpression(false));}
  /** Static constructor for a node representing an atom leaf */
  static ptr Atom(atom_ptr atom) {return ptr(new BooleanExpression(atom));}

  /**
   * Constructor for a node, providing the type and left and right child nodes.
   *
   * For unary operators, the `right` node should be an empty pointer.
   **/
  BooleanExpression(OperatorType kind, ptr left, ptr right) :
    kind(kind), left(left), right(right), atom(nullptr) {
  }

  /**
   * Constructor for a TRUE/FALSE leaf node.
   */
  BooleanExpression(bool value) : 
    left(nullptr), right(nullptr), atom(nullptr) {
    if (value) {
      kind = EXP_TRUE;
    } else {
      kind = EXP_FALSE;
    }
  }

  /** Constructor for an atom node */
  BooleanExpression(atom_ptr atom) :
    kind(EXP_ATOM), left(nullptr), right(nullptr), atom(atom) {
  }

  /** Constructor for an atom node (copies atom) */
  BooleanExpression(const Atoms& atom) :
    kind(EXP_ATOM), left(nullptr), right(nullptr), atom(new Atoms(atom)) {
  }

  /** Perform a deep copy (recursive) of this AST and return the result */
  ptr deepCopy() {
    switch (kind) {
    case EXP_AND:
      return ptr(new BooleanExpression(EXP_AND, left->deepCopy(), right->deepCopy()));
    case EXP_OR:
      return ptr(new BooleanExpression(EXP_OR, left->deepCopy(), right->deepCopy()));
    case EXP_NOT: 
      return ptr(new BooleanExpression(EXP_NOT, left->deepCopy(), nullptr));
    case EXP_TRUE:
      return True();
    case EXP_FALSE:
      return False();
    case EXP_ATOM:
      return ptr(new BooleanExpression(*atom));
    }
    throw std::logic_error("Unsupported operator");
  }

  /** Get the left child node (might be an empty pointer) */
  ptr getLeft() const {return left;}
  /** Get the right child node (might be an empty pointer) */
  ptr getRight() const {return right;}
  /** Get the atom for an EXP_ATOM node. May only be called if `isAtom() == true` */
  const Atoms& getAtom() const {
    if (!isAtom()) throw std::logic_error("Illegal access");
    return *atom;
  }

  /** Returns true if this node is an EXP_AND node */
  bool isAND() const {return kind==EXP_AND;}
  /** Returns true if this node is an EXP_OR node */
  bool isOR() const {return kind==EXP_OR;}
  /** Returns true if this node is an EXP_NOT node */
  bool isNOT() const {return kind==EXP_NOT;}
  /** Returns true if this node is an EXP_TRUE node */
  bool isTRUE() const {return kind==EXP_TRUE;}
  /** Returns true if this node is an EXP_FALSE node */
  bool isFALSE() const {return kind==EXP_FALSE;}
  /** Returns true if this node is an EXP_ATOM node */
  bool isAtom() const {return kind==EXP_ATOM;}

  /** Conjunction operator */
  friend ptr operator&(ptr left, ptr right) {
    return ptr(new BooleanExpression<Atoms>(EXP_AND, left, right));
  }

  /** Disjunction operator */
  friend ptr operator|(ptr left, ptr right) {
    return ptr(new BooleanExpression<Atoms>(EXP_OR, left, right));
  }

  /** Negation operator */
  friend ptr operator!(ptr other) {
    return ptr(new BooleanExpression<Atoms>(EXP_NOT, other, nullptr));
  }

  /** Output operator, renders in HOA syntax */
  friend std::ostream& operator<<(std::ostream& out, const BooleanExpression<Atoms>& expr) {
    switch (expr.kind) {
    case EXP_AND: {
      bool paren = expr.left->needsParentheses(EXP_AND);
      if (paren) out << "(";
      out << *expr.left;
      if (paren) out << ")";

      out << " & ";

      paren = expr.right->needsParentheses(EXP_AND);
      if (paren) out << "(";
      out << *expr.right;
      if (paren) out << ")";
      return out;
    }
    case EXP_OR: {
      bool paren = expr.left->needsParentheses(EXP_OR);
      if (paren) out << "(";
      out << *expr.left;
      if (paren) out << ")";

      out << " | ";

      paren = expr.right->needsParentheses(EXP_OR);
      if (paren) out << "(";
      out << *expr.right;
      if (paren) out << ")";
      return out;
    }
    case EXP_NOT: {
      bool paren = expr.left->needsParentheses(EXP_NOT);
      out << "!";
      if (paren) out << "(";
      out << *expr.left;
      if (paren) out << ")";
      return out;
    }
    case EXP_TRUE:
      out << "t";
      return out;
    case EXP_FALSE:
      out << "f";
      return out;
    case EXP_ATOM:
      out << *(expr.atom);
      return out;
    }
    throw std::logic_error("Unhandled operator");
  }

  /** Return a string representation of this AST (HOA syntax) */
  std::string toString() const {
    std::stringstream ss;
    ss << *this;
    return ss.str();
  }

  /**
   * Returns `true` if `expr1` and `expr2` are syntactically equal.
   * Two AST are syntactically equal if the trees match and the
   * atoms are equal.
   */
  static bool areSyntacticallyEqual(ptr expr1, ptr expr2)
  {
    if (!expr1.get() || !expr2.get()) return false;
    if (expr1->getType() != expr2->getType()) return false;

    switch (expr1->getType()) {
    case EXP_TRUE:
    case EXP_FALSE:
      return true;
    case EXP_AND:
    case EXP_OR:
      if (!areSyntacticallyEqual(expr1->getLeft(), expr2->getLeft())) return false;
      if (!areSyntacticallyEqual(expr1->getRight(), expr2->getRight())) return false;
      return true;
    case EXP_NOT:
      if (!areSyntacticallyEqual(expr1->getLeft(), expr2->getLeft())) return false;
      return true;
    case EXP_ATOM:
      return expr1->getAtom() == expr2->getAtom();
    }
    throw std::logic_error("Unknown operator in expression: "+expr1->toString());
}

private:
  /** The node type */
  OperatorType kind;
  /** The left child (if applicable) */
  ptr left;
  /** The right child (if applicable) */
  ptr right;
  /** The atom (if applicable) */
  atom_ptr atom;

  /**
   * Returns true if outputing this node in infix syntax needs parentheses,
   * if the operator above is of `enclosingType`
   */
  bool needsParentheses(OperatorType enclosingType) const {
    switch (kind) {
    case EXP_ATOM:
    case EXP_TRUE:
    case EXP_FALSE:
      return false;
    case EXP_AND:
      if (enclosingType==EXP_NOT) return true;
      if (enclosingType==EXP_AND) return false;
      if (enclosingType==EXP_OR) return false;
      break;
    case EXP_OR:
      if (enclosingType==EXP_NOT) return true;
      if (enclosingType==EXP_AND) return true;
      if (enclosingType==EXP_OR) return false;
      break;
    case EXP_NOT:
      return false;
    }
    throw std::logic_error("Unhandled operator");
  }

};

}

#endif