#include <importer_internal.hpp>

Detailed Description

Author: Joel Andersson

Date: 2010-2013

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

List of available options
Id	Type	Description	Used in
verbose	OT_BOOL	Verbose evaluation – for debugging	casadi::ImporterInternal

Definition at line 44 of file importer_internal.hpp.

Inheritance diagram for casadi::ImporterInternal:

[legend]

Collaboration diagram for casadi::ImporterInternal:

[legend]

Classes
struct	Exposed

Public Types
typedef ImporterInternal (	Creator) (const std::string &name)

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	ImporterInternal (const std::string &name)
	Constructor. More...

	~ImporterInternal () override
	Destructor. More...

std::string	class_name () const override
	Get type name. More...

void	disp (std::ostream &stream, bool more) const override
	Print. More...

void	construct (const Dict &opts)
	Construct. More...

virtual void	init (const Dict &opts)
	Initialize. More...

virtual void	finalize ()

const char *	plugin_name () const override
	Queery plugin name. More...

virtual signal_t	get_function (const std::string &symname)
	Get a function pointer for numerical evaluation. More...

bool	has_function (const std::string &symname) const
	Get a function pointer for numerical evaluation. More...

bool	has_meta (const std::string &cmd, casadi_int ind=-1) const
	Does an entry exist? More...

std::string	get_meta (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	read_meta (std::istream &file, casadi_int &offset)
	Get meta information. More...

void	read_external (const std::string &sym, bool inlined, std::istream &file, casadi_int &offset)
	Get an external function declaration. More...

bool	inlined (const std::string &symname) const

std::string	body (const std::string &symname) const
	Get the function body, if inlined. More...

virtual std::string	library () const
	Get library name. More...

virtual bool	can_have_meta () const
	Can meta information be read? More...

std::string	to_text (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	serialize (SerializingStream &s) const

virtual void	serialize_type (SerializingStream &s) const

virtual void	serialize_body (SerializingStream &s) const

casadi_int	getCount () const
	Get the reference count. More...

std::string	debug_repr (const SharedObjectInternal *) const

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...

Static Public Member Functions
static std::string	shortname ()
	Short name. More...

static std::string	indexed (const std::string &cmd, casadi_int ind)

static ImporterInternal *	deserialize (DeserializingStream &s)

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...

static ImporterInternal *	instantiate (const std::string &fname, const std::string &pname, Problem problem)

Public Attributes
std::string	name_
	C filename. More...

std::map< std::string, std::pair< casadi_int, std::string > >	meta_
	Meta data. More...

std::map< std::string, std::pair< bool, std::string > >	external_
	External functions. More...

bool	verbose_
	Verbose – for debugging purposes. More...

Static Public Attributes
static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...

static const std::string	infix_ = "importer"
	Infix. More...

Protected Member Functions
	ImporterInternal (DeserializingStream &s)

void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

static const Options	options_
	Options. More...

virtual const Options &	get_options () const
	Options. More...

Member Typedef Documentation

◆ Creator

typedef ImporterInternal*(* casadi::ImporterInternal::Creator) (const std::string &name)

Definition at line 66 of file importer_internal.hpp.

◆ RegFcn

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

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ ImporterInternal() [1/2]

casadi::ImporterInternal::ImporterInternal ( const std::string & name )

explicit

Definition at line 31 of file importer_internal.cpp.

                                                           : name_(name) {
     verbose_ = false;
   }

References verbose_.

◆ ~ImporterInternal()

casadi::ImporterInternal::~ImporterInternal ( )

override

Definition at line 35 of file importer_internal.cpp.

35 {

36 }

◆ ImporterInternal() [2/2]

casadi::ImporterInternal::ImporterInternal ( DeserializingStream & s )

explicitprotected

Definition at line 325 of file importer_internal.cpp.

                                                            {
     s.version("ImporterInternal", 1);
     s.unpack("ImporterInternal::name", name_);
     s.unpack("ImporterInternal::meta", meta_);
     s.unpack("ImporterInternal::external", external_);
   }

References external_, meta_, name_, casadi::DeserializingStream::unpack(), and casadi::DeserializingStream::version().

Member Function Documentation

◆ body()

std::string casadi::ImporterInternal::body ( const std::string & symname ) const

Definition at line 299 of file importer_internal.cpp.

                                                                  {
     auto it = external_.find(symname);
     casadi_assert_dev(it!=external_.end() && it->second.first);
     return it->second.second;
   }

References external_.

◆ can_have_meta()

virtual bool casadi::ImporterInternal::can_have_meta ( ) const

inlinevirtual

Reimplemented in casadi::DllLibrary.

Definition at line 142 of file importer_internal.hpp.

142 { return true;}

Referenced by init().

◆ class_name()

std::string casadi::ImporterInternal::class_name ( ) const

inlineoverridevirtual

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

Implements casadi::SharedObjectInternal.

Reimplemented in casadi::ShellCompiler, casadi::ClangCompiler, and casadi::DllLibrary.

Definition at line 58 of file importer_internal.hpp.

58 { return "ImporterInternal";}

Referenced by deserialize(), and serialize_type().

◆ construct()

void casadi::ImporterInternal::construct ( const Dict & opts )

Prepares the function for evaluation

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

Definition at line 57 of file importer_internal.cpp.

                                                    {
     // Sanitize dictionary is needed
     if (!Options::is_sane(opts)) {
       // Call recursively
       return construct(Options::sanitize(opts));
     }
  
     // Make sure all options exist
     get_options().check(opts);
  
     // Initialize object
     init(opts);
  
     // Revisit class hierarchy in reverse order
     finalize();
   }

References casadi::Options::check(), finalize(), get_options(), init(), casadi::Options::is_sane(), and casadi::Options::sanitize().

Referenced by casadi::Importer::create().

◆ debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal * i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                        {
     // Note: i != this because of something something multiple inheritance
     return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
   }

◆ deserialize()

ImporterInternal * casadi::ImporterInternal::deserialize ( DeserializingStream & s )

static

Definition at line 332 of file importer_internal.cpp.

                                                                         {
     std::string class_name;
     s.unpack("ImporterInternal::type", class_name);
     if (class_name=="DllLibrary") {
       return DllLibrary::deserialize(s);
     } else {
        casadi_error("Cannot deserialize type '" + class_name + "'");
     }
   }

References class_name(), casadi::DllLibrary::deserialize(), and casadi::DeserializingStream::unpack().

Referenced by casadi::Importer::deserialize().

◆ destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                             {
       static_cast<Internal*>(this)->count--;
     }

◆ disp()

void casadi::ImporterInternal::disp	(	std::ostream &	stream,
		bool	more
	)		const

overridevirtual

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

Implements casadi::SharedObjectInternal.

Definition at line 38 of file importer_internal.cpp.

38 {

39 }

◆ finalize()

virtual void casadi::ImporterInternal::finalize ( )

inlinevirtual

Reimplemented in casadi::DllLibrary.

Definition at line 88 of file importer_internal.hpp.

88 {}

Referenced by construct().

◆ get_function()

virtual signal_t casadi::ImporterInternal::get_function ( const std::string & symname )

inlinevirtual

Reimplemented in casadi::ShellCompiler, casadi::ClangCompiler, and casadi::DllLibrary.

Definition at line 110 of file importer_internal.hpp.

110 { return nullptr;}

Referenced by has_function().

◆ get_meta()

std::string casadi::ImporterInternal::get_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

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

Definition at line 283 of file importer_internal.cpp.

                                                                                  {
     if (ind>=0) return get_meta(indexed(cmd, ind));
     casadi_assert(has_meta(cmd), "No such command: " + cmd);
     return meta_.at(cmd).second;
   }

References has_meta(), indexed(), and meta_.

◆ get_options()

virtual const Options& casadi::ImporterInternal::get_options ( ) const

inlinevirtual

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

Reimplemented in casadi::ShellCompiler, and casadi::ClangCompiler.

Definition at line 80 of file importer_internal.hpp.

80 { return options_;}

casadi::ImporterInternal::options_

static const Options options_

Options.

Definition: importer_internal.hpp:79

Referenced by construct().

◆ getCount()

casadi_int casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                      {
     return static_cast<const Internal*>(this)->count;
   }

◆ getPlugin()

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

staticinherited

Definition at line 102 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_function()

bool casadi::ImporterInternal::has_function ( const std::string & symname ) const

Definition at line 214 of file importer_internal.cpp.

                                                                     {
     // Check if in meta information
     if (external_.find(symname)!=external_.end()) return true;
  
     // Convert to a dummy function pointer
     return const_cast<ImporterInternal*>(this)->get_function(symname)!=nullptr;
   }

References external_, and get_function().

◆ has_meta()

bool casadi::ImporterInternal::has_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

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

Definition at line 289 of file importer_internal.cpp.

                                                                             {
     if (ind>=0) return has_meta(indexed(cmd, ind));
     return meta_.find(cmd) != meta_.end();
   }

References indexed(), and meta_.

Referenced by get_meta().

◆ has_plugin()

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

staticinherited

Definition at line 76 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;
     }
   }

◆ indexed()

static std::string casadi::ImporterInternal::indexed	(	const std::string &	cmd,
		casadi_int	ind
	)

inlinestatic

Convert indexed command

Definition at line 150 of file importer_internal.hpp.

                                                                           {
       std::stringstream ss;
       ss << cmd << "[" << ind << "]";
       return ss.str();
     }

Referenced by get_meta(), and has_meta().

◆ init()

void casadi::ImporterInternal::init ( const Dict & opts )

virtual

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

Reimplemented in casadi::ShellCompiler, and casadi::ClangCompiler.

Definition at line 74 of file importer_internal.cpp.

                                               {
     // Read meta information from file
     if (can_have_meta()) {
       casadi_int offset = 0;
       std::ifstream file(name_);
       std::string line;
       while (getline(file, line)) {
         // Update offset
         offset++;
  
         // Try to find a /*CASADIMETA delimiter
         std::string cmd = "/*CASADIMETA";
         size_t pos = line.find(cmd);
         if (pos != std::string::npos) {
           read_meta(file, offset);
           continue;
         }
  
         // Try to find a /*CASADIEXTERNAL delimiter
         cmd = "/*CASADIEXTERNAL";
         pos = line.find(cmd);
         if (pos != std::string::npos) {
           std::istringstream ss(line.substr(pos+cmd.size()));
           // Read name
           std::string sym;
           ss >> sym;
           casadi_assert_dev(ss.good());
           // Default attributes
           bool inlined = false;
  
           // Read attributes: FIXME(@jaeandersson): Hacky
           size_t eqpos = line.find('=', pos+cmd.size());
           if (eqpos != std::string::npos) {
             std::string attr = "inline";
             if (line.compare(eqpos-attr.size(), attr.size(), attr)==0) {
               casadi_assert_dev(line.size()>eqpos+1);
               if (line.at(eqpos+1)=='1') {
                 inlined=true;
               } else {
                 casadi_assert_dev(line.at(eqpos+1)=='0');
               }
             }
           }
  
           read_external(sym, inlined, file, offset);
           continue;
         }
       }
     }
  
     // Read options
     for (auto&& op : opts) {
       if (op.first=="verbose") {
         verbose_ = op.second;
       }
     }
   }

References can_have_meta(), inlined(), name_, read_external(), read_meta(), and verbose_.

Referenced by construct(), casadi::ClangCompiler::init(), and casadi::ShellCompiler::init().

◆ initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(static_cast<Internal*>(this)->count==0);
       static_cast<Internal*>(this)->count++;
     }

◆ inlined()

bool casadi::ImporterInternal::inlined ( const std::string & symname ) const

Definition at line 294 of file importer_internal.cpp.

                                                                {
     auto it = external_.find(symname);
     return it!=external_.end() && it->second.first;
   }

References external_.

Referenced by init(), and read_external().

◆ instantiate()

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

staticinherited

Definition at line 106 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);
   }

◆ library()

std::string casadi::ImporterInternal::library ( ) const

virtual

Reimplemented in casadi::ShellCompiler, and casadi::DllLibrary.

Definition at line 305 of file importer_internal.cpp.

                                             {
     casadi_error("library not implemented.");
   }

◆ load_library()

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

staticinherited

Definition at line 92 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
   }

◆ load_plugin()

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

staticinherited

Definition at line 88 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
   }

◆ plugin_deserialize()

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

staticinherited

Definition at line 82 of file plugin_interface.hpp.

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

◆ plugin_name()

const char* casadi::ImporterInternal::plugin_name ( ) const

inlineoverridevirtual

Implements casadi::PluginInterface< ImporterInternal >.

Reimplemented in casadi::ShellCompiler, and casadi::ClangCompiler.

Definition at line 107 of file importer_internal.hpp.

107 { return "none";}

◆ plugin_options()

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

staticinherited

Definition at line 79 of file plugin_interface.hpp.

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

◆ pluginFromRegFcn()

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

staticinherited

Definition at line 85 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;
   }

◆ read_external()

void casadi::ImporterInternal::read_external	(	const std::string &	sym,
		bool	inlined,
		std::istream &	file,
		casadi_int &	offset
	)

Definition at line 179 of file importer_internal.cpp.

                                                                                           {
     // New entry
     std::stringstream ss;
  
     // Are we still in the function declaration
     bool in_declaration = true;
  
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // Skip line if still in declaration
       if (in_declaration) {
         size_t stop = line.find('{');
         if (stop != std::string::npos) in_declaration = false;
         continue;
       }
  
       // End of declaration found?
       if (line.find("/*CASADIEXTERNAL") != std::string::npos) {
         auto new_el = external_.insert(std::make_pair(sym, std::make_pair(inlined, ss.str())));
         casadi_assert(new_el.second, "Duplicate symbol: \"" + sym + "\"");
         return;
       }
  
       // Add to entry
       if (inlined) {
         ss << line << std::endl;
       }
     }
     casadi_error("End-of-file reached while searching for \"/*CASADIEXTERNAL\"");
   }

References external_, and inlined().

Referenced by init().

◆ read_meta()

void casadi::ImporterInternal::read_meta	(	std::istream &	file,
		casadi_int &	offset
	)

Definition at line 132 of file importer_internal.cpp.

                                                                        {
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // End of meta found?
       if (line.find("*/") != std::string::npos) return;
  
       // If comment or empty line, skip
       if (line.empty() || line.at(0)=='#') continue;
  
       // Get command string
       casadi_assert(line.at(0)==':',
                             "Syntax error: " + line + " is not a command string");
       std::string cmd = line.substr(1, line.find(' ')-1);
  
       // New entry
       std::stringstream ss;
  
       // Collect the meta data
       line = line.substr(cmd.size()+2);
       while (true) {
         // Find the backslash, if any
         size_t stop = line.find('\\');
  
         // Add to entry
         ss << line.substr(0, stop);
  
         // Break if not multiline
         if (stop == std::string::npos) break;
  
         // Read another line
         ss << std::endl;
         if (!getline(file, line)) {
           casadi_error("Failed to read \"" + cmd + "\"");
         }
         offset++;
       }
  
       // Insert new element in map
       auto new_el = meta_.insert(std::make_pair(cmd, std::make_pair(offset, ss.str())));
       casadi_assert(new_el.second, "Duplicate entry: \"" + cmd + "\"");
     }
     casadi_error("End-of-file reached while searching for \"*/\"");
   }

References meta_.

Referenced by init().

◆ registerPlugin() [1/2]

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

staticinherited

Definition at line 96 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;
   }

◆ registerPlugin() [2/2]

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

staticinherited

Definition at line 99 of file plugin_interface.hpp.

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

◆ serialize()

void casadi::ImporterInternal::serialize ( SerializingStream & s ) const

Definition at line 309 of file importer_internal.cpp.

                                                              {
     serialize_type(s);
     serialize_body(s);
   }

References serialize_body(), and serialize_type().

◆ serialize_body()

void casadi::ImporterInternal::serialize_body ( SerializingStream & s ) const

virtual

Definition at line 318 of file importer_internal.cpp.

                                                                   {
     s.version("ImporterInternal", 1);
     s.pack("ImporterInternal::name", name_);
     s.pack("ImporterInternal::meta", meta_);
     s.pack("ImporterInternal::external", external_);
   }

References external_, meta_, name_, casadi::SerializingStream::pack(), and casadi::SerializingStream::version().

Referenced by serialize().

◆ serialize_type()

void casadi::ImporterInternal::serialize_type ( SerializingStream & s ) const

virtual

Definition at line 314 of file importer_internal.cpp.

                                                                   {
     s.pack("ImporterInternal::type", class_name());
   }

References class_name(), and casadi::SerializingStream::pack().

Referenced by serialize().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ shortname()

static std::string casadi::ImporterInternal::shortname ( )

inlinestatic

Definition at line 104 of file importer_internal.hpp.

104 { return "importer";}

◆ to_text()

std::string casadi::ImporterInternal::to_text	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

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

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

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

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
   }

Member Data Documentation

◆ external_

std::map<std::string, std::pair<bool, std::string> > casadi::ImporterInternal::external_

Definition at line 163 of file importer_internal.hpp.

Referenced by body(), has_function(), ImporterInternal(), inlined(), read_external(), and serialize_body().

◆ infix_

const std::string casadi::ImporterInternal::infix_ = "importer"

static

Definition at line 101 of file importer_internal.hpp.

◆ meta_

std::map<std::string, std::pair<casadi_int, std::string> > casadi::ImporterInternal::meta_

Definition at line 160 of file importer_internal.hpp.

Referenced by get_meta(), has_meta(), ImporterInternal(), read_meta(), and serialize_body().

◆ name_

std::string casadi::ImporterInternal::name_

Definition at line 157 of file importer_internal.hpp.

Referenced by ImporterInternal(), init(), casadi::ClangCompiler::init(), casadi::ShellCompiler::init(), casadi::DllLibrary::init_handle(), casadi::DllLibrary::library(), and serialize_body().

◆ options_

const Options casadi::ImporterInternal::options_

static

Initial value:

= {{},
     {{"verbose",
       {OT_BOOL,
        "Verbose evaluation -- for debugging"}}
      }
    }

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

Definition at line 79 of file importer_internal.hpp.

◆ solvers_

std::map< std::string, ImporterInternal::Plugin > casadi::ImporterInternal::solvers_

static

Definition at line 94 of file importer_internal.hpp.

◆ verbose_

bool casadi::ImporterInternal::verbose_

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

Definition at line 168 of file importer_internal.hpp.

Referenced by ImporterInternal(), init(), and casadi::ShellCompiler::init().

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

Detailed Description

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Member Typedef Documentation

◆ Creator

◆ RegFcn

◆ weak_ref_type

Constructor & Destructor Documentation

◆ ImporterInternal() [1/2]

◆ ~ImporterInternal()

◆ ImporterInternal() [2/2]

Member Function Documentation

◆ body()

◆ can_have_meta()

◆ class_name()

◆ construct()

◆ debug_repr()

◆ deserialize()

◆ destroySingleton()

◆ disp()

◆ finalize()

◆ get_function()

◆ get_meta()

◆ get_options()

◆ getCount()

◆ getPlugin()

◆ has_function()

◆ has_meta()

◆ has_plugin()

◆ indexed()

◆ init()

◆ initSingleton()

◆ inlined()

◆ instantiate()

◆ library()

◆ load_library()

◆ load_plugin()

◆ plugin_deserialize()

◆ plugin_name()

◆ plugin_options()

◆ pluginFromRegFcn()

◆ read_external()

◆ read_meta()

◆ registerPlugin() [1/2]

◆ registerPlugin() [2/2]

◆ serialize()

◆ serialize_body()

◆ serialize_type()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ shortname()

◆ to_text()

◆ weak()

Member Data Documentation

◆ external_

◆ infix_

◆ meta_

◆ name_

◆ options_

◆ solvers_

◆ verbose_