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

#include "SeVec3d.h"
#include <vector>

class SeExpression;
class SeExprFuncNode;


class SeExprFuncX {
public:
    SeExprFuncX(const bool threadSafe)
        :_threadSafe(threadSafe)
    {}

    virtual bool prep(SeExprFuncNode* node, bool wantVec);

    virtual void eval(const SeExprFuncNode* node, SeVec3d& result) const = 0;
    virtual ~SeExprFuncX(){}

    bool isThreadSafe() const {return _threadSafe;}
private:
    bool _threadSafe;
};


class SeExprFunc {
public:

    static void init(); 
    static void loadPlugins(const char* path);
    static void loadPlugin(const char* path);

    /* A pointer to the define func is passed to the init method of
       expression plugins.  This should be called instead of calling
       the static method directly so that the plugin will work if the
       expression library is statically linked. */
    static void define(const char* name, SeExprFunc f,const char* docString);
    static void define(const char* name, SeExprFunc f);
    typedef void (*Define) (const char* name, SeExprFunc f);
    typedef void (*Define3) (const char* name, SeExprFunc f,const char* docString);

    static const SeExprFunc* lookup(const std::string& name);

    static void getFunctionNames(std::vector<std::string>& names);

    static std::string getDocString(const char* functionName);

    typedef double Func0();
    typedef double Func1(double);
    typedef double Func2(double, double);
    typedef double Func3(double, double, double);
    typedef double Func4(double, double, double, double);
    typedef double Func5(double, double, double, double, double);
    typedef double Func6(double, double, double, double, double, double);
    typedef double Func1v(const SeVec3d&);
    typedef double Func2v(const SeVec3d&, const SeVec3d&);
    typedef SeVec3d Func1vv(const SeVec3d&);
    typedef SeVec3d Func2vv(const SeVec3d&, const SeVec3d&);
    typedef double Funcn(int n, double* params);
    typedef double Funcnv(int n, const SeVec3d* params);
    typedef SeVec3d Funcnvv(int n, const SeVec3d* params);

    enum FuncType {
        NONE=0, 
        // scalar args and result
        FUNC0, FUNC1, FUNC2, FUNC3, FUNC4, FUNC5, FUNC6, FUNCN,
        // vector args, scalar result
        VEC, FUNC1V=VEC, FUNC2V, FUNCNV,
        // vector args and result
        VECVEC, FUNC1VV=VECVEC, FUNC2VV, FUNCNVV,
        // extension type
        FUNCX
    };
    bool hasVecArgs() const { return _type >= VEC; }
    bool isVec() const { return _type >= VECVEC; }

    SeExprFunc() : _type(NONE), _func(0), _minargs(0), _maxargs(0) {}

    SeExprFunc(Func0* f) : _type(FUNC0), _func((void*)f), _minargs(0), _maxargs(0) {}
    SeExprFunc(Func1* f) : _type(FUNC1), _func((void*)f), _minargs(1), _maxargs(1) {}
    SeExprFunc(Func2* f) : _type(FUNC2), _func((void*)f), _minargs(2), _maxargs(2) {}
    SeExprFunc(Func3* f) : _type(FUNC3), _func((void*)f), _minargs(3), _maxargs(3) {}
    SeExprFunc(Func4* f) : _type(FUNC4), _func((void*)f), _minargs(4), _maxargs(4) {}
    SeExprFunc(Func5* f) : _type(FUNC5), _func((void*)f), _minargs(5), _maxargs(5) {}
    SeExprFunc(Func6* f) : _type(FUNC6), _func((void*)f), _minargs(6), _maxargs(6) {}
    SeExprFunc(Func1v* f) : _type(FUNC1V), _func((void*)f), _minargs(1), _maxargs(1) {}
    SeExprFunc(Func2v* f) : _type(FUNC2V), _func((void*)f), _minargs(2), _maxargs(2) {}
    SeExprFunc(Func1vv* f) : _type(FUNC1VV), _func((void*)f), _minargs(1), _maxargs(1) {}
    SeExprFunc(Func2vv* f) : _type(FUNC2VV), _func((void*)f), _minargs(2), _maxargs(2) {}
    SeExprFunc(Funcn* f, int minargs, int maxargs)
        : _type(FUNCN), _func((void*)f), _minargs(minargs), _maxargs(maxargs) {}
    SeExprFunc(Funcnv* f, int minargs, int maxargs)
        : _type(FUNCNV), _func((void*)f), _minargs(minargs), _maxargs(maxargs) {}
    SeExprFunc(Funcnvv* f, int minargs, int maxargs)
        : _type(FUNCNVV), _func((void*)f), _minargs(minargs), _maxargs(maxargs) {}
    SeExprFunc(SeExprFuncX& f, int minargs=1, int maxargs=1)
        : _type(FUNCX), _func((void*)&f), _minargs(minargs), _maxargs(maxargs) {}

    int type() const { return _type; }
    int minArgs() const { return _minargs; }
    int maxArgs() const { return _maxargs; }
    Func0* func0() const { return (Func0*)_func; }
    Func1* func1() const { return (Func1*)_func; }
    Func2* func2() const { return (Func2*)_func; }
    Func3* func3() const { return (Func3*)_func; }
    Func4* func4() const { return (Func4*)_func; }
    Func5* func5() const { return (Func5*)_func; }
    Func6* func6() const { return (Func6*)_func; }
    Func1v* func1v() const { return (Func1v*)_func; }
    Func2v* func2v() const { return (Func2v*)_func; }
    Func1vv* func1vv() const { return (Func1vv*)_func; }
    Func2vv* func2vv() const { return (Func2vv*)_func; }
    Funcn* funcn() const { return (Funcn*)_func; }
    Funcnv* funcnv() const { return (Funcnv*)_func; }
    Funcnvv* funcnvv() const { return (Funcnvv*)_func; }
    SeExprFuncX* funcx() const { return (SeExprFuncX*)_func; }

private:
    FuncType _type;
    void* _func;
    int _minargs;
    int _maxargs;
};

#endif

---