Dynamically linked library. More...

#include <importer_internal.hpp>

Detailed Description

Author: Joel Andersson

Date: 2016

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

Definition at line 187 of file importer_internal.hpp.

Inheritance diagram for casadi::DllLibrary:

[legend]

Collaboration diagram for casadi::DllLibrary:

[legend]

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

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	DllLibrary (const std::string &bin_name)

void	finalize () override

void	init_handle ()

	~DllLibrary () override

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

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

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

bool	can_have_meta () const override
	Can meta information be read? 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...

const char *	plugin_name () const override
	Queery plugin name. 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...

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

virtual void	deps_version_check (const std::string &stage) const

Static Public Member Functions
static ImporterInternal *	deserialize (DeserializingStream &s)

static std::string	shortname ()
	Short name. More...

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

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

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

static const Options	options_
	Options. More...

Member Typedef Documentation

◆ Creator

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

inherited

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

◆ DllLibrary() [1/2]

casadi::DllLibrary::DllLibrary ( const std::string & bin_name )

explicit

Definition at line 225 of file importer_internal.cpp.

     : ImporterInternal(bin_name), handle_(nullptr) {
  
   }

Referenced by deserialize().

◆ ~DllLibrary()

casadi::DllLibrary::~DllLibrary ( )

override

Definition at line 258 of file importer_internal.cpp.

                           {
 #ifdef WITH_DL
   if (handle_) close_shared_library(handle_);
 #endif // WITH_DL
   }

◆ DllLibrary() [2/2]

casadi::DllLibrary::DllLibrary ( DeserializingStream & s )

inlineexplicitprotected

Definition at line 225 of file importer_internal.hpp.

225 : ImporterInternal(s) {}

Member Function Documentation

◆ body()

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

inherited

Definition at line 306 of file importer_internal.cpp.

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

References casadi::ImporterInternal::external_.

◆ can_have_meta()

bool casadi::DllLibrary::can_have_meta ( ) const

inlineoverridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 220 of file importer_internal.hpp.

220 { return false;}

◆ class_name()

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

inlineoverridevirtual

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

Reimplemented from casadi::ImporterInternal.

Definition at line 211 of file importer_internal.hpp.

211 { return "DllLibrary";}

◆ construct()

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

inherited

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
       construct(Options::sanitize(opts));
       return;
     }
  
     // Make sure all options exist
     get_options().check(opts);
  
     // Initialize object
     init(opts);
  
     // Revisit class hierarchy in reverse order
     finalize();
   }

References casadi::Options::check(), casadi::ImporterInternal::finalize(), casadi::ImporterInternal::get_options(), casadi::ImporterInternal::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();
   }

◆ deps_version_check()

virtual void casadi::PluginInterface< ImporterInternal >::deps_version_check ( const std::string & stage ) const

inlinevirtualinherited

Definition at line 112 of file plugin_interface.hpp.

112 {}

◆ deserialize()

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

static

Definition at line 349 of file importer_internal.cpp.

                                                                   {
     DllLibrary* ret = new DllLibrary(s);
     ret->finalize();
     return ret;
   }

References DllLibrary(), and finalize().

Referenced by casadi::ImporterInternal::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

overridevirtualinherited

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()

void casadi::DllLibrary::finalize ( )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 254 of file importer_internal.cpp.

                             {
     init_handle();
   }

References init_handle().

Referenced by deserialize().

◆ get_function()

signal_t casadi::DllLibrary::get_function ( const std::string & symname )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 264 of file importer_internal.cpp.

                                                         {
 #ifdef WITH_DL
 #ifdef _WIN32
 #if __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
     return reinterpret_cast<signal_t>(GetProcAddress(handle_, TEXT(sym.c_str())));
 #if __GNUC__
 #pragma GCC diagnostic pop
 #endif
 #else // _WIN32
     signal_t fcnPtr = reinterpret_cast<signal_t>(dlsym(handle_, sym.c_str()));
     if (dlerror()) {
       fcnPtr=nullptr;
       dlerror(); // Reset error flags
     }
     return fcnPtr;
 #endif // _WIN32
 #else // WITH_DL
     (void)sym;
     casadi_error("DllLibrary::get_function: WITH_DL option needed for dynamic loading");
     return nullptr;
 #endif // WITH_DL
   }

◆ get_meta()

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

inherited

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

Definition at line 290 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 casadi::ImporterInternal::has_meta(), casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

◆ get_options()

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

inlinevirtualinherited

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 casadi::ImporterInternal::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

inherited

Definition at line 217 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 casadi::ImporterInternal::external_, and casadi::ImporterInternal::get_function().

◆ has_meta()

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

inherited

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

Definition at line 296 of file importer_internal.cpp.

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

References casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::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
	)

inlinestaticinherited

Convert indexed command

Definition at line 150 of file importer_internal.hpp.

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

Referenced by casadi::ImporterInternal::get_meta(), and casadi::ImporterInternal::has_meta().

◆ init()

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

virtualinherited

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

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

Definition at line 75 of file importer_internal.cpp.

                                               {
     // Read meta information from file
     if (can_have_meta()) {
       casadi_int offset = 0;
       auto file_ptr = Filesystem::ifstream_ptr(name_);
       std::istream& file = *file_ptr;
  
       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 casadi::ImporterInternal::can_have_meta(), casadi::Filesystem::ifstream_ptr(), casadi::ImporterInternal::inlined(), casadi::ImporterInternal::name_, casadi::ImporterInternal::read_external(), casadi::ImporterInternal::read_meta(), and casadi::ImporterInternal::verbose_.

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

◆ init_handle()

void casadi::DllLibrary::init_handle ( )

Definition at line 230 of file importer_internal.cpp.

                                {
  
     std::vector<std::string> search_paths = get_search_paths();
  
     if (Filesystem::is_enabled() && Filesystem::has_parent_path(name_)) {
       std::string dir = Filesystem::parent_path(name_);
       // Does search path already contain the directory?
       for (const std::string& path : search_paths) {
         if (path==dir) {
           dir = "";
           break;
         }
       }
       // Add directory to search path
       if (!dir.empty()) search_paths.push_back(dir);
     }
  
 #ifdef WITH_DL
     handle_ = open_shared_library(name_, search_paths, "DllLibrary::init_handle");
 #else // WITH_DL
     casadi_error("CommonExternal: WITH_DL  not activated");
 #endif // WITH_DL
   }

References casadi::get_search_paths(), casadi::Filesystem::has_parent_path(), casadi::Filesystem::is_enabled(), casadi::ImporterInternal::name_, casadi::Filesystem::parent_path(), and casadi::path().

Referenced by finalize().

◆ 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

inherited

Definition at line 301 of file importer_internal.cpp.

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

References casadi::ImporterInternal::external_.

Referenced by casadi::ImporterInternal::init(), and casadi::ImporterInternal::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::DllLibrary::library ( ) const

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 355 of file importer_internal.cpp.

                                       {
     return name_;
   }

References casadi::ImporterInternal::name_.

◆ 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 = std::string(CasadiMeta::shared_library_prefix()) + libname +
                       CasadiMeta::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

inlineoverridevirtualinherited

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
	)

inherited

Definition at line 182 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 casadi::ImporterInternal::external_, and casadi::ImporterInternal::inlined().

Referenced by casadi::ImporterInternal::init().

◆ read_meta()

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

inherited

Definition at line 135 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 casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::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

inherited

Definition at line 316 of file importer_internal.cpp.

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

References casadi::ImporterInternal::serialize_body(), and casadi::ImporterInternal::serialize_type().

◆ serialize_body()

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

virtualinherited

Definition at line 325 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 casadi::ImporterInternal::external_, casadi::ImporterInternal::meta_, casadi::ImporterInternal::name_, casadi::SerializingStream::pack(), and casadi::SerializingStream::version().

Referenced by casadi::ImporterInternal::serialize().

◆ serialize_type()

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

virtualinherited

Definition at line 321 of file importer_internal.cpp.

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

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

Referenced by casadi::ImporterInternal::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 ( )

inlinestaticinherited

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

inherited

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.

                                                                                   {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     auto* w = weak_ref_.load(std::memory_order_acquire);
     if (!w) {
       auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
       GenericWeakRef<Shared, Internal>* expected = nullptr;
       if (weak_ref_.compare_exchange_strong(
             expected, nw, std::memory_order_release, std::memory_order_acquire)) {
         w = nw;
       } else {
         delete nw; // lost the race; another thread published first
         w = expected;
       }
     }
     return w;
 #else
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
   }

Member Data Documentation

◆ external_

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

inherited

Definition at line 163 of file importer_internal.hpp.

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

◆ infix_

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

staticinherited

Definition at line 101 of file importer_internal.hpp.

◆ meta_

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

inherited

Definition at line 160 of file importer_internal.hpp.

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

◆ name_

std::string casadi::ImporterInternal::name_

inherited

Definition at line 157 of file importer_internal.hpp.

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

◆ options_

const Options casadi::ImporterInternal::options_

staticinherited

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_

staticinherited

Definition at line 94 of file importer_internal.hpp.

◆ verbose_

bool casadi::ImporterInternal::verbose_

inherited

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

Definition at line 168 of file importer_internal.hpp.

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

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

Detailed Description

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

◆ DllLibrary() [1/2]

◆ ~DllLibrary()

◆ DllLibrary() [2/2]

Member Function Documentation

◆ body()

◆ can_have_meta()

◆ class_name()

◆ construct()

◆ debug_repr()

◆ deps_version_check()

◆ deserialize()

◆ destroySingleton()

◆ disp()

◆ finalize()

◆ get_function()

◆ get_meta()

◆ get_options()

◆ getCount()

◆ getPlugin()

◆ has_function()

◆ has_meta()

◆ has_plugin()

◆ indexed()

◆ init()

◆ init_handle()

◆ 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_