Expression.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef EXPRESSION__HPP
#define EXPRESSION__HPP
 
#include <iostream>
#include <string>
#include <list>
#include <map>
 
#include "RinexObsHeader.hpp"
#include "RinexObsData.hpp"
#include "ObsEpochMap.hpp"
#include "Exception.hpp"
 
namespace gnsstk
{
 
 
   NEW_EXCEPTION_CLASS(ExpressionException, Exception);
 
   class Expression
   {
   public:
 
      Expression(void);
 
      Expression(const std::string& str);
 
      Expression(const Expression& rhs);
 
      ~Expression(void);
 
      Expression& operator=(const Expression& rhs);
 
 
      bool set(const std::string name, double value);
 
      bool set(const char* name, double value)
         { return set (std::string(name),value); }
 
      bool setGPSConstants(void);
 
      bool setRinexObs(const RinexObsData::RinexObsTypeMap& rotm);
 
      bool setSvObsEpoch(const SvObsEpoch& soe);
 
      bool canEvaluate(void);
 
      double evaluate(void)
         { return root->getValue(); }
 
      void print(std::ostream& ostr) const {root->print(ostr);}
 
      private:
      // Represents a node of any type in an expression tree.
      class ExpNode {
         public:
 
         virtual ~ExpNode() {}
 
         virtual double getValue() = 0;
 
 
         // Write out this node to a stream
        virtual std::ostream& print(std::ostream& ostr) =0;
 
      }; // end class ExpNode
 
 
      // Represents a node that holds a number.
      class ConstNode : public ExpNode {
         public:
            // Constructor.  Create a node to hold val.
            ConstNode( double theNum ): number(theNum) {}
 
            double getValue()
               { return number; }
 
            std::ostream& print(std::ostream& ostr) {
               ostr << number;
               return ostr;
            }
 
            double number;  // The number in the node.
      }; // end class ConstNode
 
      // Represents a node that holds a variable
      class VarNode : public ExpNode {
         public:
            // Constructor.
 
            VarNode(std::string theName ): name(theName), hasValue(false)
                {}
 
         double getValue();
 
            std::ostream& print(std::ostream& ostr) {
               ostr << name;
               return ostr;
            }
 
            std::string name;  // The name of the varaible
            bool hasValue;
 
         void setValue(double newValue);
 
        private:
            double value;
 
 
      }; // end class VarNode
 
      // Represents a node that holds an operator.
      class BinOpNode : public ExpNode {
         public:
 
            // Constructor.  Create a node to hold the given data.
            BinOpNode( const std::string& theOp, ExpNode *theLeft, ExpNode *theRight ):
                    op(theOp), left(theLeft), right(theRight){}
 
         double getValue();
 
            std::ostream& print(std::ostream& ostr);
 
            std::string op;        // The operator.
            ExpNode *left;   // The left operand.
            ExpNode *right;  // The right operand.
 
      }; // end class BinOpNode
 
      // Represents a node that holds a function of a signle variable
      class FuncOpNode : public ExpNode {
         public:
 
            // Constructor.  Create a node to hold the given data.
            FuncOpNode( const std::string& theOp, ExpNode *theRight ):
                    op(theOp), right(theRight){}
 
         double getValue();
 
            std::ostream& print(std::ostream& ostr);
 
            std::string op;        // The operator.
            ExpNode *right;  // The right operand.
 
      }; // end class FuncOpNode
 
         // This class is used internally, during construction of an Expression,
         // to generate ExpNodes.
      class Token
      {
         public:
 
            Token(std::string value, int relPriority,
                  bool isOperator);
 
            std::string getValue(void) {return value;}
 
            int getPriority(void) {return priority;}
 
            void setUsed(void) {used=true;}
            bool getUsed(void) {return used;}
 
            ExpNode * getNode(void) {return expNode;}
            void setNode(ExpNode *newNode) {expNode = newNode; }
 
            void setResolved(bool value) {resolved=value;}
            bool getResolved(void) {return resolved;}
 
            bool getOperator(void) {return isOperator;}
            void setOperator(bool value) {isOperator = value;}
 
            std::string getArgumentPattern(void) {return argumentPattern;}
            void setArgumentPattern(std::string value) {argumentPattern = value;}
 
            void print(std::ostream& ostr);
 
         private:
 
            std::string value;
            bool isOperator;
            bool resolved;
 
            int priority;
            ExpNode *expNode;
            bool used; // has the node of this token been used (linked to?)
 
            std::string argumentPattern;
      };
 
         void setExpression(const std::string& newExpression);
         void dumpLists(void);
 
         void defineOperators(void);
         void tokenize(const std::string& str);
         void buildExpressionTree(void);
 
         int countResolvedTokens(void);
 
         static std::map<std::string,int> operatorMap;
         static std::map<std::string,std::string> argumentPatternMap;
         static bool operatorsDefined;
 
         std::list<Token> tList;
         std::list<ExpNode *> eList;
         ExpNode *root;
   }; // End class expression
 
 
} // End namespace gnsstk
 
#endif // EXPRESSION_HPP