/disk1/scratch/aselle/projects/seexpr/SeExpr/src/SeExpr/SeExpression.h

Go to the documentation of this file.

/*
* (c) Disney Enterprises, Inc.  All rights reserved.
*
* This file is licensed under the terms of the Microsoft Public License (MS-PL)
* as defined at: http://opensource.org/licenses/MS-PL.
*
* A complete copy of this license is included in this distribution as the file
* LICENSE.
*/
#ifndef SeExpression_h
#define SeExpression_h

#include <string>
#include <map>
#include <set>
#include <vector>
#include <SeExprMacros.h>
#include "SeVec3d.h"

class SeExprNode;
class SeExprVarNode;
class SeExprLocalVarRef;
class SeExprFunc;
class SeExpression;

class SeExprVarRef
{
 public:
    virtual ~SeExprVarRef() {}

    virtual bool isVec() = 0;

    virtual void eval(const SeExprVarNode* node, SeVec3d& result) = 0;
};

class SeExprVectorVarRef : public SeExprVarRef
{
 public:
    virtual bool isVec() { return 1; }
};


class SeExprScalarVarRef : public SeExprVarRef
{
 public:
    virtual bool isVec() { return 0; }
};

class SeExprLocalVarRef : public SeExprVarRef
{
 public:
    SeVec3d val;
    SeExprLocalVarRef() : _isVec(false) {}
    void setIsVec() { _isVec = true; }
    virtual void eval(const SeExprVarNode*, SeVec3d& result) 
    { result = val; }
    virtual bool isVec() { return _isVec; }
 private:
    bool _isVec;
};


class SeExpression
{
 public:
    typedef std::map<std::string, SeExprLocalVarRef> LocalVarTable;

    struct Error
    {
        std::string error;

        int startPos;

        int endPos;

        Error(const std::string& errorIn,const int startPosIn,const int endPosIn)
            :error(errorIn),startPos(startPosIn),endPos(endPosIn)
        {}
    };

    SeExpression( );
    SeExpression( const std::string &e, bool wantVec=true );
    virtual ~SeExpression();

    void setWantVec(bool wantVec);

    void setExpr(const std::string& e);

    const std::string& getExpr() const { return _expression; }

    bool syntaxOK() const;

    bool isValid() const;

    const std::string& parseError() const { return _parseError; }

    const std::vector<Error>& getErrors() const
    {return _errors;}

    bool isConstant() const;

    bool usesVar(const std::string& name) const;

    bool usesFunc(const std::string& name) const;

    bool isThreadSafe() const
    {return _threadUnsafeFunctionCalls.size()==0;}

    void setThreadUnsafe(const std::string& functionName) const
    {_threadUnsafeFunctionCalls.push_back(functionName);}

    const std::vector<std::string>& getThreadUnsafeFunctionCalls() const
    {return _threadUnsafeFunctionCalls;}
    
    bool wantVec() const { return _wantVec; }

    bool isVec() const;

    SeVec3d evaluate() const;

    void reset();

    virtual SeExprVarRef* resolveVar(const std::string& /*name*/) const {return 0;}

    virtual SeExprFunc* resolveFunc(const std::string& /*name*/) const {return 0;}

    void addError(const std::string& error,const int startPos,const int endPos) const
    {_errors.push_back(Error(error,startPos,endPos));}

    const LocalVarTable& getLocalVars() const {return _localVars;}

 private:
    SeExpression( const SeExpression &e );
    SeExpression &operator=( const SeExpression &e );

    void parse() const;

    void prep() const;

    void parseIfNeeded() const { if (!_parsed) parse(); }

    void prepIfNeeded() const { if (!_prepped) prep(); }

    bool _wantVec;

    std::string _expression;
    
    mutable SeExprNode *_parseTree;

    mutable bool _parsed, _prepped;
    
    mutable std::string _parseError;

    mutable std::vector<Error> _errors;

    mutable std::set<std::string> _vars;

    mutable std::set<std::string> _funcs;

    mutable LocalVarTable _localVars;

    mutable std::vector<std::string> _threadUnsafeFunctionCalls;

    mutable std::vector<char*> _stringTokens;

    /* internal */ public:

    void addVar(const char* n) const { _vars.insert(n); }

    void addFunc(const char* n) const { _funcs.insert(n); }

    SeExprVarRef* resolveLocalVar(const char* n) const {
        LocalVarTable::iterator iter = _localVars.find(n);
        if (iter != _localVars.end()) return &iter->second;
        return 0;
    }

    SeExprLocalVarRef* getLocalVar(const char* n) const {
        return &_localVars[n]; 
    }
};

#endif

---