casadi::PluginInterface< Derived > Class Template Reference

Interface for accessing input and output data structures. More...

#include <plugin_interface.hpp>

Detailed Description

template<class Derived>
class casadi::PluginInterface< Derived >

Author

Joel Andersson

Date

2013

Extra doc: https://github.com/casadi/casadi/wiki/L_rp

Definition at line 54 of file plugin_interface.hpp.

Classes
struct	Plugin
	Fields. More...

Public Types
typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
virtual const char *	plugin_name () const =0
void	serialize_type (SerializingStream &s) const
	Serialize type information. More...

Static Public Member Functions
static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...
static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...
static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...
static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...
static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...
static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...
static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...
static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...
static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...
template<class Problem >
static Derived *	instantiate (const std::string &fname, const std::string &pname, Problem problem)
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize with type disambiguation. More...

Member Typedef Documentation

RegFcn

template<class Derived >

typedef int(* casadi::PluginInterface< Derived >::RegFcn) (Plugin *plugin)

Definition at line 73 of file plugin_interface.hpp.

Member Function Documentation

deserialize()

template<class Derived >

static ProtoFunction* casadi::PluginInterface< Derived >::deserialize ( DeserializingStream &  s )

inlinestatic

Extra doc: https://github.com/casadi/casadi/wiki/L_rr

Definition at line 121 of file plugin_interface.hpp.

                                                              {
      std::string class_name, plugin_name;
      s.unpack("PluginInterface::plugin_name", plugin_name);
      Deserialize deserialize = plugin_deserialize(plugin_name);
      return deserialize(s);
    }

References casadi::PluginInterface< Derived >::plugin_deserialize(), casadi::PluginInterface< Derived >::plugin_name(), and casadi::DeserializingStream::unpack().

Referenced by casadi::Conic::deserialize(), casadi::Integrator::deserialize(), casadi::Interpolant::deserialize(), casadi::LinsolInternal::deserialize(), casadi::Nlpsol::deserialize(), and casadi::Rootfinder::deserialize().

getPlugin()

template<class Derived >

PluginInterface< Derived >::Plugin & casadi::PluginInterface< Derived >::getPlugin ( const std::string &  pname )

static

Definition at line 291 of file plugin_interface.hpp.

                                                            {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Check if the solver has been loaded
    auto it=Derived::solvers_.find(pname);
 
    // Load the solver if needed
    if (it==Derived::solvers_.end()) {
      load_plugin(pname, true, false);
      it=Derived::solvers_.find(pname);
    }
    casadi_assert_dev(it!=Derived::solvers_.end());
    return it->second;
  }

has_plugin()

template<class Derived >

bool casadi::PluginInterface< Derived >::has_plugin ( const std::string &  pname, bool  verbose = false  )

static

Definition at line 131 of file plugin_interface.hpp.

                                                                                {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Quick return if available
    if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
      return true;
    }
 
    // Try loading the plugin
    try {
      (void)load_plugin(pname, false, false);
      return true;
    } catch (CasadiException& ex) {
      if (verbose) {
        casadi_warning(ex.what());
      }
      return false;
    }
  }

References casadi::find(), and casadi::CasadiException::what().

instantiate()

template<class Derived >

template<class Problem >

Derived * casadi::PluginInterface< Derived >::instantiate ( const std::string &  fname, const std::string &  pname, Problem  problem  )

static

Definition at line 311 of file plugin_interface.hpp.

                                                       {
 
    // Assert the plugin exists (needed for adaptors)
    if (!has_plugin(pname, true)) {
      casadi_error("Plugin '" + pname + "' is not found.");
    }
    return getPlugin(pname).creator(fname, problem);
  }

load_library()

template<class Derived >

handle_t casadi::PluginInterface< Derived >::load_library ( const std::string &  libname, std::string &  resultpath, bool  global  )

static

Definition at line 183 of file plugin_interface.hpp.

                                        {
 
#ifndef WITH_DL
    casadi_error("WITH_DL option needed for dynamic loading");
#else // WITH_DL
 
    // Get the name of the shared library
    std::string lib = SHARED_LIBRARY_PREFIX + libname + SHARED_LIBRARY_SUFFIX;
 
    // Build up search paths;
    std::vector<std::string> search_paths = get_search_paths();
    return open_shared_library(lib, search_paths, resultpath,
      "PluginInterface::load_plugin", global);
 
#endif // WITH_DL
  }

References casadi::get_search_paths().

load_plugin()

template<class Derived >

PluginInterface< Derived >::Plugin casadi::PluginInterface< Derived >::load_plugin ( const std::string &  pname, bool  register_plugin = true, bool  needs_lock = true  )

static

Definition at line 203 of file plugin_interface.hpp.

                                               {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Issue warning and quick return if already loaded
    if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
      casadi_warning("PluginInterface: Solver " + pname + " is already in use. Ignored.");
      return Plugin();
    }
 
    // Logger singletons are lazily instantiated on first uout()/uerr() calls
    // This instantation may lead to a data race with potential instatiations in plugin
    // To be safe, trigger instantatin before any plugin loading
    uout();
    uerr();
 
#ifndef WITH_DL
    casadi_error("WITH_DL option needed for dynamic loading");
#else // WITH_DL
    // Retrieve the registration function
    RegFcn reg;
 
    // Load the dll
    std::string regName = "casadi_register_" + Derived::infix_ + "_" + pname;
 
    std::string searchpath;
    handle_t handle = load_library("casadi_" + Derived::infix_ + "_" + pname, searchpath,
      false);
 
#ifdef _WIN32
 
#if __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
    reg = reinterpret_cast<RegFcn>(GetProcAddress(handle, TEXT(regName.c_str())));
#if __GNUC__
#pragma GCC diagnostic pop
#endif
 
#else // _WIN32
    // Reset error
    dlerror();
 
    // Load creator
    reg = reinterpret_cast<RegFcn>(dlsym(handle, regName.c_str()));
#endif // _WIN32
    casadi_assert(reg!=nullptr,
      "PluginInterface::load_plugin: no \"" + regName + "\" found in " + searchpath + ".");
 
    // Create a temporary struct
    Plugin plugin = pluginFromRegFcn(reg);
    // Register the plugin
    if (register_plugin) {
      registerPlugin(plugin, false);
    }
 
    return plugin;
 
#endif // WITH_DL
  }

References casadi::find(), casadi::uerr(), and casadi::uout().

plugin_deserialize()

template<class Derived >

Deserialize casadi::PluginInterface< Derived >::plugin_deserialize ( const std::string &  pname )

static

Definition at line 162 of file plugin_interface.hpp.

                                                                                 {
    Deserialize m = getPlugin(pname).deserialize;
    casadi_assert(m, "Plugin \"" + pname + "\" does not support deserialize");
    return m;
  }

Referenced by casadi::PluginInterface< Derived >::deserialize().

plugin_name()

template<class Derived >

virtual const char* casadi::PluginInterface< Derived >::plugin_name ( ) const

pure virtual

Implemented in casadi::LinsolInternal, casadi::SymbolicQr, casadi::Sqpmethod, casadi::ShellCompiler, casadi::Scpgen, casadi::RungeKutta, casadi::Qrsqp, casadi::Qrqp, casadi::QpToNlp, casadi::Newton, casadi::Lsqr, casadi::LinsolTridiag, casadi::LinsolQr, casadi::LinsolLdl, casadi::LinearInterpolant, casadi::Ipqp, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::Collocation, casadi::BSplineInterpolant, casadi::WorhpInterface, casadi::TinyXmlInterface, casadi::SuperscsInterface, casadi::KinsolInterface, casadi::IdasInterface, casadi::CvodesInterface, casadi::SqicInterface, casadi::SnoptInterface, casadi::SlicotExpm, casadi::SlicotDple, casadi::SLEQPInterface, casadi::QpoasesInterface, casadi::ProxqpInterface, casadi::OsqpInterface, casadi::OoqpInterface, casadi::MumpsInterface, casadi::MadnlpInterface, casadi::LapackQr, casadi::LapackLu, casadi::KnitroInterface, casadi::IpoptInterface, casadi::Ma27Interface, casadi::HpmpcInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::GurobiInterface, casadi::FatropInterface, casadi::FatropConicInterface, casadi::DaqpInterface, casadi::CsparseInterface, casadi::CSparseCholeskyInterface, casadi::CplexInterface, casadi::ClpInterface, casadi::ClarabelInterface, casadi::ClangCompiler, casadi::CbcInterface, casadi::BonminInterface, casadi::Blocksqp, casadi::AmplInterface, casadi::AlpaqaInterface, and casadi::ImporterInternal.

Referenced by casadi::PluginInterface< Derived >::deserialize(), and casadi::PluginInterface< Derived >::serialize_type().

plugin_options()

template<class Derived >

const Options & casadi::PluginInterface< Derived >::plugin_options ( const std::string &  pname )

static

Definition at line 155 of file plugin_interface.hpp.

                                                                                {
    const Options *op = getPlugin(pname).options;
    casadi_assert(op!=nullptr, "Plugin \"" + pname + "\" does not support options");
    return *op;
  }

pluginFromRegFcn()

template<class Derived >

PluginInterface< Derived >::Plugin casadi::PluginInterface< Derived >::pluginFromRegFcn ( RegFcn  regfcn )

static

Definition at line 170 of file plugin_interface.hpp.

                                                              {
    // Create a temporary struct
    Plugin plugin;
 
    // Set the fields
    int flag = regfcn(&plugin);
    casadi_assert(flag==0, "Registration of plugin failed.");
 
    return plugin;
  }

registerPlugin() [1/2]

template<class Derived >

void casadi::PluginInterface< Derived >::registerPlugin ( const Plugin &  plugin, bool  needs_lock = true  )

static

Definition at line 274 of file plugin_interface.hpp.

                                                                                     {
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
    // Check if the solver name is in use
    typename std::map<std::string, Plugin>::iterator it=Derived::solvers_.find(plugin.name);
    casadi_assert(it==Derived::solvers_.end(),
      "Solver " + str(plugin.name) + " is already in use");
 
    // Add to list of solvers
    Derived::solvers_[plugin.name] = plugin;
  }

References casadi::PluginInterface< Derived >::Plugin::name, and casadi::str().

registerPlugin() [2/2]

template<class Derived >

void casadi::PluginInterface< Derived >::registerPlugin ( RegFcn  regfcn, bool  needs_lock = true  )

static

Definition at line 269 of file plugin_interface.hpp.

                                                                              {
    registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
  }

serialize_type()

template<class Derived >

void casadi::PluginInterface< Derived >::serialize_type ( SerializingStream &  s ) const

inline

Extra doc: https://github.com/casadi/casadi/wiki/L_rq

Definition at line 114 of file plugin_interface.hpp.

                                                    {
      s.pack("PluginInterface::plugin_name", std::string(plugin_name()));
    }

References casadi::SerializingStream::pack(), and casadi::PluginInterface< Derived >::plugin_name().

Referenced by casadi::Conic::serialize_type(), casadi::Integrator::serialize_type(), casadi::Interpolant::serialize_type(), casadi::LinsolInternal::serialize_type(), casadi::Nlpsol::serialize_type(), and casadi::Rootfinder::serialize_type().

---

The documentation for this class was generated from the following file:

• plugin_interface.hpp