CustomFunction.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef CUSTOMFUNCTION_H
#define CUSTOMFUNCTION_H

#include <dlfcn.h>

#include "Displayable.h"
#include "RealFunction.h"
#include "Surface/ComplexFunction.h"
#include "Surface/Surface.h"

#include <QString>

class QString;

template<class function_type>
        class CustomFunctionBase {
    public:
        CustomFunctionBase(): handle (NULL) {}
        ~CustomFunctionBase() { if (handle) dlclose (handle); }
        QString symbolic () const;

        bool isValid() const { return valid; }

    protected:
        bool loadFunction (const QString &, QString = "f");

        void setValid() { valid = true; }
        void setInvalid() { valid = false; }

        function_type *func;

    private:
        void *handle;   
        bool valid;     
};


class CustomFunction:
        public RealFunction,
        public CustomFunctionBase<RealFunction::raw_function_type> {
    public:
        CustomFunction (double _tmin, double _tmax, double _dt,
                        double _umin, double _umax, double _du,
                        double _vmin, double _vmax, double _dv,
                        bool final = true);
        virtual ~CustomFunction() { }

        virtual std::string getFunctionName() const;

    protected:
        virtual RealFunction::function_type f;
};


class CustomPolarFunction: public CustomFunction {
    public:
        CustomPolarFunction (double _tmin, double _tmax, double _dt,
                             double _umin, double _umax, double _du,
                             double _vmin, double _vmax, double _dv);
        virtual ~CustomPolarFunction() { }

        virtual std::string getFunctionName() const;

    protected:
        virtual RealFunction::function_type f;
};


class CustomSurface:
        public Surface,
        public CustomFunctionBase<Surface::raw_function_type> {
    public:
        CustomSurface (double _umin, double _umax, double _du,
                       double _vmin, double _vmax, double _dv);
        virtual ~CustomSurface() { }

        virtual std::string getFunctionName() const;

    protected:
        virtual Surface::function_type f;
};


class CustomComplexFunction:
    public ComplexFunction,
    public CustomFunctionBase<ComplexFunction::function_type> {

public:

  CustomComplexFunction (): ComplexFunction() { }
  CustomComplexFunction (double _umin, double _umax, double _du,
                         double _vmin, double _vmax, double _dv);
        virtual ~CustomComplexFunction() { }

        virtual std::string getFunctionName() const;

    protected:
        ComplexFunction::function_type g;
};

namespace {
  Displayable *createcustomcomplexfunction() { return new CustomComplexFunction(); }
  const bool registeredustomcomplexfunction = true;
//    TheFunctionFactory::Instance().registerFunction(createcustomcomplexfunction, "ComplexFunction");
}

template<class function_type>
        bool CustomFunctionBase<function_type>::loadFunction(const QString &libName, QString funcName) {
    const char *error;

    handle = dlopen (libName.toStdString().c_str(), RTLD_LAZY);
    if (!handle) {
        std::cerr << "Error opening library: " << dlerror() << std::endl;
        return false;
    }

    func = (function_type *)dlsym(handle, funcName.toStdString().c_str());
    if ((error = dlerror()) != NULL)  {
        std::cerr << "Error finding function: " << error << std::endl;
        return false;
    }

    return true;
}

template<class function_type>
QString CustomFunctionBase<function_type>::symbolic () const {
    typedef char* STRING;
    STRING (*sym)();
    sym = (STRING (*)())dlsym(handle, "symbolic");
    const char *error;
    static char *ret;

    if ((error = dlerror()) != NULL)  {
        std::cerr << "Error finding symbolic description in " << error << std::endl;
        return QString ("something");
    }
    ret=(*sym)();
    return QString (ret);
}

#endif