casadi-bindings-control-2.0.0.1: cbits/autogen/control_classes.cpp

#include "casadi/control/dple_solver.hpp"
#include "casadi/core/casadi_calculus.hpp"
#include "casadi/core/casadi_exception.hpp"
#include "casadi/core/casadi_meta.hpp"
#include "casadi/core/casadi_options.hpp"
#include "casadi/core/casadi_types.hpp"
#include "casadi/core/function/control_simulator.hpp"
#include "casadi/core/function/custom_function.hpp"
#include "casadi/core/function/external_function.hpp"
#include "casadi/core/function/function.hpp"
#include "casadi/core/function/homotopy_nlp_solver.hpp"
#include "casadi/core/function/implicit_function.hpp"
#include "casadi/core/function/integrator.hpp"
#include "casadi/core/function/io_interface.hpp"
#include "casadi/core/function/linear_solver.hpp"
#include "casadi/core/function/lp_solver.hpp"
#include "casadi/core/function/mx_function.hpp"
#include "casadi/core/function/nlp_solver.hpp"
#include "casadi/core/function/nullspace.hpp"
#include "casadi/core/function/ocp_solver.hpp"
#include "casadi/core/function/parallelizer.hpp"
#include "casadi/core/function/qcqp_solver.hpp"
#include "casadi/core/function/qp_solver.hpp"
#include "casadi/core/function/sdp_solver.hpp"
#include "casadi/core/function/sdqp_solver.hpp"
#include "casadi/core/function/simulator.hpp"
#include "casadi/core/function/socp_solver.hpp"
#include "casadi/core/function/stabilized_qp_solver.hpp"
#include "casadi/core/function/sx_function.hpp"
#include "casadi/core/functor.hpp"
#include "casadi/core/generic_type.hpp"
#include "casadi/core/matrix/generic_expression.hpp"
#include "casadi/core/matrix/generic_matrix.hpp"
#include "casadi/core/matrix/matrix.hpp"
#include "casadi/core/matrix/matrix_tools.hpp"
#include "casadi/core/matrix/slice.hpp"
#include "casadi/core/matrix/sparsity.hpp"
#include "casadi/core/matrix/sparsity_tools.hpp"
#include "casadi/core/misc/integration_tools.hpp"
#include "casadi/core/misc/symbolic_nlp.hpp"
#include "casadi/core/mx/mx.hpp"
#include "casadi/core/mx/mx_tools.hpp"
#include "casadi/core/options_functionality.hpp"
#include "casadi/core/printable_object.hpp"
#include "casadi/core/shared_object.hpp"
#include "casadi/core/std_vector_tools.hpp"
#include "casadi/core/sx/sx_element.hpp"
#include "casadi/core/sx/sx_tools.hpp"
#include "casadi/core/weak_ref.hpp"
#include <cmath>
#include <sstream>
#include <stdexcept>
#include "../marshal.hpp"

// ================== delete UserType (Namespace ["casadi"]) (Name "DpleSolver")===============
// classType: UserType (Namespace ["casadi"]) (Name "DpleSolver")
extern "C"
    void delete_casadi__DpleSolver(casadi::DpleSolver* obj);
void delete_casadi__DpleSolver(casadi::DpleSolver* obj){
    delete obj;
}

// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver"
// cWrapperName: "casadi__DpleSolver__CONSTRUCTOR__0"
// protoArgs: "(std::string ** err_msg, std::string* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2)"
// args: "(x0_, x1_, x2_)"
// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
// cWrapperRetType: "casadi::DpleSolver*"
// proto: "casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2)"
// call: "casadi::DpleSolver(x0_, x1_, x2_)"
// params: [Ref (Const StdString),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity")))),Ref (Const (StdVec (UserType (Namespace ["casadi"]) (Name "Sparsity"))))]
extern "C"
    casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2);
casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__0(std::string ** err_msg, std::string* x0, std::vector< casadi::Sparsity* >* x1, std::vector< casadi::Sparsity* >* x2){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);
        std::vector< casadi::Sparsity > x1_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x1);
        std::vector< casadi::Sparsity > x2_ = Marshaling<std::vector< casadi::Sparsity >,std::vector< casadi::Sparsity* >*>::marshal(x2);

        casadi::DpleSolver ret = casadi::DpleSolver(x0_, x1_, x2_);
        return WrapReturn< casadi::DpleSolver*, casadi::DpleSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Constructor method: "CONSTRUCTOR" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver"
// cWrapperName: "casadi__DpleSolver__CONSTRUCTOR__1"
// protoArgs: "(std::string ** err_msg)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
// cWrapperRetType: "casadi::DpleSolver*"
// proto: "casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg)"
// call: "casadi::DpleSolver()"
// params: []
extern "C"
    casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg);
casadi::DpleSolver* casadi__DpleSolver__CONSTRUCTOR__1(std::string ** err_msg){
    try {

        casadi::DpleSolver ret = casadi::DpleSolver();
        return WrapReturn< casadi::DpleSolver*, casadi::DpleSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Normal method: "clone" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver::clone"
// cWrapperName: "casadi__DpleSolver__clone"
// protoArgs: "(std::string ** err_msg, casadi::DpleSolver* obj)"
// args: "()"
// rettype: UserType (Namespace ["casadi"]) (Name "DpleSolver")
// cWrapperRetType: "casadi::DpleSolver*"
// proto: "casadi::DpleSolver* casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj)"
// call: "obj->clone()"
// params: []
extern "C"
    casadi::DpleSolver* casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj);
casadi::DpleSolver* casadi__DpleSolver__clone(std::string ** err_msg, casadi::DpleSolver* obj){
    try {

        casadi::DpleSolver ret = obj->clone();
        return WrapReturn< casadi::DpleSolver*, casadi::DpleSolver >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "doc" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver::doc"
// cWrapperName: "casadi__DpleSolver__doc"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: StdString
// cWrapperRetType: "std::string*"
// proto: "std::string* casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0)"
// call: "casadi::DpleSolver::doc(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    std::string* casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0);
std::string* casadi__DpleSolver__doc(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

        std::string ret = casadi::DpleSolver::doc(x0_);
        return WrapReturn< std::string*, std::string >::wrapReturn( ret );
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return 0;
    }
}


// ================== Static method: "loadPlugin" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver::loadPlugin"
// cWrapperName: "casadi__DpleSolver__loadPlugin"
// protoArgs: "(std::string ** err_msg, std::string* x0)"
// args: "(x0_)"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0)"
// call: "casadi::DpleSolver::loadPlugin(x0_)"
// params: [Ref (Const StdString)]
extern "C"
    void casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0);
void casadi__DpleSolver__loadPlugin(std::string ** err_msg, std::string* x0){
    try {
        std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);

    casadi::DpleSolver::loadPlugin(x0_);
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}


// ================== Normal method: "printStats" ===============
// class: "casadi::DpleSolver"
// cppName: "casadi::DpleSolver::printStats"
// cWrapperName: "casadi__DpleSolver__printStats"
// protoArgs: "(std::string ** err_msg, casadi::DpleSolver* obj)"
// args: "()"
// rettype: CVoid
// cWrapperRetType: "void"
// proto: "void casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj)"
// call: "obj->printStats()"
// params: []
extern "C"
    void casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj);
void casadi__DpleSolver__printStats(std::string ** err_msg, casadi::DpleSolver* obj){
    try {

    obj->printStats();
    } catch (std::exception& ex) {
         *err_msg = new std::string(ex.what());
         return;
    }
}