octeval.h

/*
    mbxmlutils-eval-octave:
    Octave implementation of the 'eval' plugin interface of MBXMLUtils
 
    Copyright (C) Markus Friedrich
 
    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 3 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, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef _MBXMLUTILS_OCTEVAL_H_
#define _MBXMLUTILS_OCTEVAL_H_
 
#include "eval.h"
#include <memory>
 
class octave_value;
class octave_value_list;
class octave_function;
 
namespace fmatvec {
  class SymbolicExpression;
}
 
namespace XERCES_CPP_NAMESPACE { class DOMElement; }
 
namespace MBXMLUtils {
 
std::shared_ptr<octave_value> C(const Eval::Value &value);
 
Eval::Value C(const octave_value &value);
 
class OctEval;
 
class OctEval : public Eval {
  friend class Eval;
 
  protected:
    OctEval(std::vector<boost::filesystem::path> *dependencies_=nullptr);
 
  public:
    ~OctEval() override;
 
    static std::string getNameStatic() { return "octave"; }
    std::string getName() const override { return getNameStatic(); }
 
    void addImport(const std::string &code, const xercesc::DOMElement *e, const std::string &action="") override;
 
    void addImportHelper(const boost::filesystem::path &dir);
 
    bool valueIsOfType(const Value &value, ValueType type) const override;
 
    std::map<boost::filesystem::path, std::pair<boost::filesystem::path, bool> >& requiredFiles() const override;
 
    void convertIndex(Value &v, bool evalTo1Based) override {}
 
  protected:
 
    struct Import {
      std::string path;
      std::map<std::string, octave_value> vn;
      std::map<std::string, octave_value> gvn;
      std::map<std::string, octave_value> ufn;
      std::map<std::string, octave_value> tlvn;
    };
 
    Value createFunctionIndep(int dim) const override;
 
    Value fullStringToValue(const std::string &str, const xercesc::DOMElement *e, bool skipRet=false) const override;
 
    static octave_value_list fevalThrow(octave_function *func, const octave_value_list &arg, int n=0,
                                        const std::string &msg=std::string());
 
    static void* getSwigPtr(const octave_value &v);
    static Value createSwigByTypeName(const std::string &name);
    static std::string getSwigType(const octave_value &value);
 
    Value callFunction(const std::string &name, const std::vector<Value>& args) const override;
 
    double                            cast_double              (const Value &value) const override;
    std::vector<double>               cast_vector_double       (const Value &value) const override;
    std::vector<std::vector<double> > cast_vector_vector_double(const Value &value) const override;
    std::string                       cast_string              (const Value &value) const override;
 
    Value create_double              (const double& v) const override;
    Value create_vector_double       (const std::vector<double>& v) const override;
    Value create_vector_vector_double(const std::vector<std::vector<double> >& v) const override;
    Value create_string              (const std::string& v) const override;
 
    std::string createSourceCode_double              (const double& v) const override;
    std::string createSourceCode_vector_double       (const std::vector<double>& v) const override;
    std::string createSourceCode_vector_vector_double(const std::vector<std::vector<double> >& v) const override;
    std::string createSourceCode_string              (const std::string& v) const override;
 
    Value createFunctionDep(const std::vector<Value>& v) const override;
    Value createFunctionDep(const std::vector<std::vector<Value> >& v) const override;
    Value createFunction(const std::vector<Value> &indeps, const Value &dep) const override;
 
    std::string serializeFunction(const Value &x) const override;
};
 
} // end namespace MBXMLUtils
 
#endif