AbstractObjects/Expressions.h

Go to the documentation of this file.

//
// Namespace Expressions
//   This namespace contains the representations for all OPAL expressions
//   (scalar and array). It also defines the entire user interface for
//   the expression parser. All classes derived from these classes are
//   declared in this same namespace in the module "Expressions".
//
//   The expression parser is a recursive-descent parser.  When a parse
//   routine recognizes an expression, it returns its internal represenation
//   and skips the corresponding input tokens.  In case of error, a
//   ParseError exception is thrown.
//
// Template class: Expression::Scalar<T>
//   This abstract base class defines the interface for OPAL scalar
//   expressions whose values have type T.
//
// Template class: Expression::Array<T>
//   This abstract base class defines the interface for OPAL array
//   expressions whose components have type T.
//
// Template class: Expression::PtrToScalar<T>
//   This class implements a pointer which owns a scalar expression
//   of type Expression::Scalar<T>.
//
// Template class: Expression::PtrToArray<T>
//   This class implements a pointer which owns an array expression
//   of type Expression::Array<T>.
//
// Template class: Expression::ArrayOfPtrs<T>
//   This class implements an array of pointers, each of which owns
//   an expression of type Expression::Scalar<T>.
//
// Declared functions:
//   A collection of functions implementing a recursive descent parser.
//
//
// Copyright (c) 2008-2020
// Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved.
//
// OPAL is licensed under GNU GPL version 3.
//
 
#ifndef OPAL_Expressions_HH
#define OPAL_Expressions_HH 1
 
#include <iosfwd>
#include <list>
#include <memory>
#include <string>
#include <vector>
#include "OpalParser/Token.h"
 
class PlaceRep;
class RangeRep;
class SFunction;
class Statement;
class Table;
class TableRowRep;
 
// ========================================================================
 
namespace Expressions {
 
    // Template class Expression::Scalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    class Scalar {
    public:
        Scalar();
        Scalar(const Scalar&);
        virtual ~Scalar();
 
        //  Deep copy of the expression.
        virtual Scalar<T>* clone() const = 0;
 
        //  Recursively evaluate the expression and return the result.
        //  Any non-deferred values are cached.
        virtual T evaluate() const = 0;
 
        //  Default action assumes non-constant.
        virtual bool isConstant() const;
 
        //  Print the expression on the specified stream.
        //  The [b]precedence[/b] parameter controls printing of parentheses.
        virtual void print(std::ostream&, int precedence = 99) const = 0;
 
    private:
        // Not implemented.
        void operator=(const Scalar&);
    };
 
    // Template class Expression::PtrToScalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    class PtrToScalar {
    public:
        PtrToScalar(Scalar<T>* rhs);
 
        PtrToScalar();
        PtrToScalar(const PtrToScalar& rhs);
        PtrToScalar(PtrToScalar&& rhs) noexcept = default;
        ~PtrToScalar();
        PtrToScalar& operator=(const PtrToScalar&);
        PtrToScalar& operator=(PtrToScalar&&) noexcept = default;
        PtrToScalar& operator=(Scalar<T>* rhs);
 
        Scalar<T>* operator->() const { return ptr_m.get(); }
        Scalar<T>& operator*() const { return *ptr_m; }
        explicit operator bool() const { return ptr_m != nullptr; }
        bool isValid() const { return ptr_m != nullptr; }
        Scalar<T>* release() { return ptr_m.release(); }
        Scalar<T>* get() const { return ptr_m.get(); }
 
    private:
        // Mutable to preserve transfer-on-copy semantics from OwnPtr.
        mutable std::unique_ptr<Scalar<T>> ptr_m;
    };
 
    // Template class Expression::ArrayOfPtrs<T>.
    // ------------------------------------------------------------------------
 
    template <class T>
    class ArrayOfPtrs : public std::vector<PtrToScalar<T>> {
    public:
        ArrayOfPtrs();
        ArrayOfPtrs(int);
        ArrayOfPtrs(const std::vector<PtrToScalar<T>>& rhs);
        ~ArrayOfPtrs();
    };
 
    // Template class Expression::Array<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    class OArray {
    public:
        OArray();
        OArray(const OArray&);
        virtual ~OArray();
 
        //  Deep copy.
        virtual OArray<T>* clone() const = 0;
 
        //  Recursively evaluate the expression and return the result.
        //  Any non-deferred expression is cached.
        virtual std::vector<T> evaluate() const = 0;
 
        //  Default action assumes non-constant.
        virtual bool isConstant() const;
 
        //  Print the expression on the specified stream.
        //  The [b]precedence[/b] parameter controls printing of parentheses.
        virtual void print(std::ostream&, int precedence = 99) const = 0;
 
    private:
        // Not implemented.
        void operator=(const OArray&);
    };
 
    // Template class Expression::PtrToArray<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    class PtrToArray {
    public:
        PtrToArray(OArray<T>* rhs);
 
        PtrToArray();
        PtrToArray(const PtrToArray& rhs);
        PtrToArray(PtrToArray&& rhs) noexcept = default;
        ~PtrToArray();
        PtrToArray& operator=(const PtrToArray<T>&);
        PtrToArray& operator=(PtrToArray&&) noexcept = default;
        PtrToArray& operator=(OArray<T>* rhs);
 
        OArray<T>* operator->() const { return ptr_m.get(); }
        OArray<T>& operator*() const { return *ptr_m; }
        explicit operator bool() const { return ptr_m != nullptr; }
        bool isValid() const { return ptr_m != nullptr; }
        OArray<T>* release() { return ptr_m.release(); }
        OArray<T>* get() const { return ptr_m.get(); }
 
    private:
        // Mutable to preserve transfer-on-copy semantics from OwnPtr.
        mutable std::unique_ptr<OArray<T>> ptr_m;
    };
 
    // ----------------------------------------------------------------------
    // SCALAR EXPRESSION PARSERS.
 
    extern PtrToScalar<bool> parseBool(Statement&);
 
    extern PtrToScalar<double> parseReal(Statement&);
 
    extern double parseRealConst(Statement&);
 
    //  When no string is seen, a ParseError is thrown with the message
    //  given as the second argument.
    extern std::string parseString(Statement&, const char msg[]);
    extern std::string parseStringValue(Statement&, const char msg[]);
 
    // ARRAY EXPRESSION PARSERS.
 
    extern PtrToArray<bool> parseBoolArray(Statement&);
 
    extern PtrToArray<double> parseRealArray(Statement&);
 
    extern PtrToArray<double> parseRealConstArray(Statement&);
 
    extern std::vector<std::string> parseStringArray(Statement&);
 
    // SPECIAL VALUE PARSERS.
 
    extern void parseDelimiter(Statement& stat, char delim);
 
    extern void parseDelimiter(Statement& stat, const char delim[2]);
 
    extern PlaceRep parsePlace(Statement&);
 
    extern RangeRep parseRange(Statement&);
 
    // Forward declaration.
    template <class T>
    class SRefAttr;
 
    extern SRefAttr<double>* parseReference(Statement&);
 
    extern TableRowRep parseTableRow(Statement&);
 
    extern std::list<Token> parseTokenList(Statement&);
 
    extern std::vector<std::list<Token>> parseTokenListArray(Statement&);
 
    // SPECIAL PARSER.
 
    extern PtrToScalar<double> parseTableExpression(Statement&, const Table*);
 
    // Implementation of class Expression::Scalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    inline Scalar<T>::Scalar() {}
 
    template <class T>
    inline Scalar<T>::Scalar(const Scalar<T>&) {}
 
    template <class T>
    inline Scalar<T>::~Scalar() {}
 
    template <class T>
    inline bool Scalar<T>::isConstant() const {
        return false;
    }
 
    // Implementation of class Expression::OArray<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    inline OArray<T>::OArray() {}
 
    template <class T>
    inline OArray<T>::OArray(const OArray<T>&) {}
 
    template <class T>
    inline OArray<T>::~OArray() {}
 
    template <class T>
    inline bool OArray<T>::isConstant() const {
        return false;
    }
 
    // Implementation of class Expression::PtrToScalar<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    inline PtrToScalar<T>::PtrToScalar() : ptr_m() {}
 
    template <class T>
    inline PtrToScalar<T>::PtrToScalar(const PtrToScalar& rhs) : ptr_m(std::move(rhs.ptr_m)) {}
 
    template <class T>
    inline PtrToScalar<T>::PtrToScalar(Scalar<T>* rhs) : ptr_m(rhs) {}
 
    template <class T>
    inline PtrToScalar<T>::~PtrToScalar() {}
 
    template <class T>
    inline PtrToScalar<T>& PtrToScalar<T>::operator=(const PtrToScalar& rhs) {
        if (this != &rhs) {
            ptr_m = std::move(rhs.ptr_m);
        }
        return *this;
    }
 
    template <class T>
    inline PtrToScalar<T>& PtrToScalar<T>::operator=(Scalar<T>* rhs) {
        ptr_m.reset(rhs);
        return *this;
    }
 
    // Implementation of class Expression::ArrayOfPtrs<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    inline ArrayOfPtrs<T>::ArrayOfPtrs() : std::vector<PtrToScalar<T>>() {}
 
    template <class T>
    inline ArrayOfPtrs<T>::ArrayOfPtrs(int n) : std::vector<PtrToScalar<T>>(n, PtrToScalar<T>()) {}
 
    template <class T>
    inline ArrayOfPtrs<T>::ArrayOfPtrs(const std::vector<PtrToScalar<T>>& rhs)
        : std::vector<PtrToScalar<T>>(rhs) {}
 
    template <class T>
    inline ArrayOfPtrs<T>::~ArrayOfPtrs() {}
 
    // Implementation of class Expression::PtrToArray<T>.
    // ----------------------------------------------------------------------
 
    template <class T>
    inline PtrToArray<T>::PtrToArray() : ptr_m() {}
 
    template <class T>
    inline PtrToArray<T>::PtrToArray(const PtrToArray& rhs) : ptr_m(std::move(rhs.ptr_m)) {}
 
    template <class T>
    inline PtrToArray<T>::PtrToArray(OArray<T>* rhs) : ptr_m(rhs) {}
 
    template <class T>
    inline PtrToArray<T>::~PtrToArray() {}
 
    template <class T>
    inline PtrToArray<T>& PtrToArray<T>::operator=(const PtrToArray& rhs) {
        if (this != &rhs) {
            ptr_m = std::move(rhs.ptr_m);
        }
        return *this;
    }
 
    template <class T>
    inline PtrToArray<T>& PtrToArray<T>::operator=(OArray<T>* rhs) {
        ptr_m.reset(rhs);
        return *this;
    }
 
    // End of namespace Expressions.
    // ======================================================================
};  // namespace Expressions
 
#endif  // OPAL_Expressions_HH