/disk1/scratch/aselle/projects/seexpr/SeExpr/src/SeExpr/SeExprNode.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 SeExprNode_h
#define SeExprNode_h

#ifndef MAKEDEPEND
#include <string.h>
#include <string>
#include <vector>
#endif

#include "SeExpression.h"
#include "SeVec3d.h"

class SeExprFunc;

class SeExprNode {
public:
    SeExprNode(const SeExpression* expr);
    SeExprNode(const SeExpression* expr, SeExprNode* a);
    SeExprNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b);
    SeExprNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b, SeExprNode* c);
    virtual ~SeExprNode();

    bool isVec() const { return _isVec; }

    virtual void eval(SeVec3d& v) const;

    const SeExpression* expr() const { return _expr; }

    const SeExprNode* parent() const { return _parent; }
    int numChildren() const { return _children.size(); }
    const SeExprNode* child(int i) const { return _children[i]; }
    SeExprNode* child(int i) { return _children[i]; }

    void addChild(SeExprNode* child);

    void addChildren(SeExprNode* surrogate);

    virtual bool prep(bool wantVec);

    inline void setPosition(const short int startPos,const short int endPos)
    {_startPos=startPos;_endPos=endPos;}

    inline void addError(const std::string& error)
    {_expr->addError(error,_startPos,_endPos);}

protected:
    const SeExpression* _expr;

    SeExprNode* _parent;

    std::vector<SeExprNode*> _children;

    bool _isVec;

    unsigned short int _startPos,_endPos;
};


class SeExprBlockNode : public SeExprNode
{
public:
    SeExprBlockNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprIfThenElseNode : public SeExprNode
{
public:
    SeExprIfThenElseNode(const SeExpression* expr,
                         SeExprNode* a, SeExprNode* b, SeExprNode* c) :
        SeExprNode(expr, a, b, c) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprAssignNode : public SeExprNode
{
public:
    SeExprAssignNode(const SeExpression* expr, const char* name, SeExprNode* e) :
        SeExprNode(expr, e), _name(name), _var(0) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;

private:
    const char* _name; // this is owned by the SeExprNode's parent SeExpression
    SeExprLocalVarRef* _var; // this is owned by the SeExprNode's parent SeExpression
};


class SeExprVecNode : public SeExprNode
{
public:
    SeExprVecNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b, SeExprNode* c) :
        SeExprNode(expr, a, b, c) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprNegNode : public SeExprNode
{
public:
    SeExprNegNode(const SeExpression* expr, SeExprNode* a) :
        SeExprNode(expr, a) {}

    virtual void eval(SeVec3d& result) const;
};

class SeExprInvertNode : public SeExprNode
{
public:
    SeExprInvertNode(const SeExpression* expr, SeExprNode* a) :
        SeExprNode(expr, a) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprNotNode : public SeExprNode
{
public:
    SeExprNotNode(const SeExpression* expr, SeExprNode* a) :
        SeExprNode(expr, a) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprCondNode : public SeExprNode
{
public:
    SeExprCondNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b, SeExprNode* c) :
        SeExprNode(expr, a, b, c) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprAndNode : public SeExprNode
{
public:
    SeExprAndNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprOrNode : public SeExprNode
{
public:
    SeExprOrNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprSubscriptNode : public SeExprNode
{
public:
    SeExprSubscriptNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
};


class SeExprCompareEqNode : public SeExprNode
{
public:
    SeExprCompareEqNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
};


class SeExprCompareNode : public SeExprNode
{
public:
    SeExprCompareNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual bool prep(bool wantVec);
};


class SeExprEqNode : public SeExprCompareEqNode
{
public:
    SeExprEqNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareEqNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprNeNode : public SeExprCompareEqNode
{
public:
    SeExprNeNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareEqNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprLtNode : public SeExprCompareNode
{
public:
    SeExprLtNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprGtNode : public SeExprCompareNode
{
public:
    SeExprGtNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprLeNode : public SeExprCompareNode
{
public:
    SeExprLeNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprGeNode : public SeExprCompareNode
{
public:
    SeExprGeNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprCompareNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprAddNode : public SeExprNode
{
public:
    SeExprAddNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprSubNode : public SeExprNode
{
public:
    SeExprSubNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprMulNode : public SeExprNode
{
public:
    SeExprMulNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprDivNode : public SeExprNode
{
public:
    SeExprDivNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprModNode : public SeExprNode
{
public:
    SeExprModNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};


class SeExprExpNode : public SeExprNode
{
public:
    SeExprExpNode(const SeExpression* expr, SeExprNode* a, SeExprNode* b) :
        SeExprNode(expr, a, b) {}

    virtual void eval(SeVec3d& result) const;
};

class SeExprVarNode : public SeExprNode
{
public:
    SeExprVarNode(const SeExpression* expr, const char* name) :
        SeExprNode(expr), _name(name), _var(0), _data(0) 
    { expr->addVar(name); }

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
    const char* name() const { return _name; }
    
    struct Data { virtual ~Data() {} };
    void setData(Data* data) const { _data = data; }
    Data* getData() const { return _data; }

private:
    const char* _name; // this is owned by the SeExprNode's parent SeExpression
    SeExprVarRef* _var; // this is owned by somebody else
    mutable Data* _data;
};


class SeExprNumNode : public SeExprNode
{
public:
    SeExprNumNode(const SeExpression* expr, double val) :
        SeExprNode(expr), _val(val) {}

    virtual void eval(SeVec3d& result) const { result[0] = _val; }

private:
    double _val;
};


class SeExprStrNode : public SeExprNode
{
public:
    SeExprStrNode(const SeExpression* expr, const char* str) :
        SeExprNode(expr), _str(str) {}

    virtual bool prep(bool /*wantVec*/)
    { addError("Invalid string parameter: "+_str); return 0; }

    virtual void eval(SeVec3d& result) const { result[0] = 0; }
    const char* str() const { return _str.c_str(); }

private:
    std::string _str;
};


class SeExprFuncNode : public SeExprNode
{
public:
    SeExprFuncNode(const SeExpression* expr, const char* name) :
        SeExprNode(expr), _name(name), _func(0), _nargs(0), _data(0) 
    {
        expr->addFunc(name);
    }
    virtual ~SeExprFuncNode() { delete _data; }

    virtual bool prep(bool wantVec);
    virtual void eval(SeVec3d& result) const;
    void setIsVec(bool isVec) { _isVec = isVec; }
    const char* name() const { return _name.c_str(); }


    int nargs() const { return _nargs; }

    double* scalarArgs() const { return &_scalarArgs[0]; }
    SeVec3d* vecArgs() const { return &_vecArgs[0]; }

    SeVec3d* evalArgs() const;

    SeVec3d evalArg(int n) const;

    bool isStrArg(int n) const;

    std::string getStrArg(int n) const;

    struct Data { virtual ~Data() {} };

    /***
        Use this to set data associated with the node. Equivalently this is data
        associated with a specific evaluation point of a function.
        Examples would be tokenized values, 
        sorted lists for binary searches in curve evaluation, etc. This should be done
        in SeExprFuncX::prep().
    */
    void setData(Data* data) const { _data = data; }

    /***
        Use this to get data associated in the prep() routine. This is typically
        used from SeExprFuncX::eval()
    */
    Data* getData() const { return _data; }

private:
    std::string _name;
    const SeExprFunc* _func;
    int _nargs;
    mutable std::vector<double> _scalarArgs;
    mutable std::vector<SeVec3d> _vecArgs;
    mutable Data* _data;
};

#endif

---