casadi::LaceModelica Class Reference

'lacemodelica' plugin for ModelicaParser More...

#include <lace_modelica.hpp>

Detailed Description

ModelicaParser using LaceModelica

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

Definition at line 48 of file lace_modelica.hpp.

Inheritance diagram for casadi::LaceModelica:

Collaboration diagram for casadi::LaceModelica:

Public Types
typedef ModelicaParserInternal *(*	Creator) ()
using	weak_ref_type = WeakRefInternal
typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	LaceModelica ()
const char *	plugin_name () const override
std::string	class_name () const override
	Readable name of the internal class. More...
void	parse (const std::string &filename, const std::string &output_dir) override
	~LaceModelica () override
void	disp (std::ostream &stream, bool more=false) const override
	Print a description. More...
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
void	serialize_type (SerializingStream &s) const
	Serialize type information. More...

Static Public Member Functions
static ModelicaParserInternal *	creator ()
	Create a new ModelicaParser. More...
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 ModelicaParserInternal *	instantiate (const std::string &fname, const std::string &pname, Problem problem)
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize with type disambiguation. More...

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...
static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...
static const std::string	infix_ = "modelicaparser"
	Infix. More...

Protected Member Functions
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...

Member Typedef Documentation

Creator

typedef ModelicaParserInternal*(* casadi::ModelicaParserInternal::Creator) ()

inherited

Definition at line 54 of file modelica_parser_internal.hpp.

RegFcn

typedef int(* casadi::PluginInterface< ModelicaParserInternal >::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

LaceModelica()

casadi::LaceModelica::LaceModelica

(

)

Definition at line 46 of file lace_modelica.cpp.

                            {
}

~LaceModelica()

casadi::LaceModelica::~LaceModelica ( )

override

Definition at line 49 of file lace_modelica.cpp.

                            {
}

Member Function Documentation

class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 62 of file lace_modelica.hpp.

{ return "LaceModelica";}

creator()

static ModelicaParserInternal* casadi::LaceModelica::creator ( )

inlinestatic

Definition at line 55 of file lace_modelica.hpp.

    { return new LaceModelica();}

Referenced by casadi::casadi_register_modelicaparser_lacemodelica().

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< ModelicaParserInternal >::deps_version_check ( const std::string &  stage ) const

inlinevirtualinherited

Definition at line 112 of file plugin_interface.hpp.

{}

deserialize()

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

inlinestaticinherited

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

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

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::ModelicaParserInternal::disp ( std::ostream &  stream, bool  more = false  ) const

overridevirtualinherited

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

Implements casadi::SharedObjectInternal.

Definition at line 44 of file modelica_parser_internal.cpp.

                                                                     {
}

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< ModelicaParserInternal >::Plugin & casadi::PluginInterface< ModelicaParserInternal >::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_plugin()

bool casadi::PluginInterface< ModelicaParserInternal >::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;
    }
  }

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++;
    }

instantiate()

ModelicaParserInternal * casadi::PluginInterface< ModelicaParserInternal >::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);
  }

load_library()

handle_t casadi::PluginInterface< ModelicaParserInternal >::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< ModelicaParserInternal >::Plugin casadi::PluginInterface< ModelicaParserInternal >::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
  }

parse()

void casadi::LaceModelica::parse ( const std::string &  filename, const std::string &  output_dir  )

overridevirtual

Reimplemented from casadi::ModelicaParserInternal.

Definition at line 52 of file lace_modelica.cpp.

                                                                               {
  lacemodelica_status_t status = lacemodelica_process_bmo(filename.c_str(), output_dir.c_str());
  casadi_assert(status == LACEMODELICA_SUCCESS,
    "lacemodelica_process_bmo failed: " + std::string(lacemodelica_status_string(status)));
}

References casadi::filename().

plugin_deserialize()

Deserialize casadi::PluginInterface< ModelicaParserInternal >::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::LaceModelica::plugin_name ( ) const

inlineoverridevirtual

Implements casadi::PluginInterface< ModelicaParserInternal >.

Definition at line 59 of file lace_modelica.hpp.

{ return "lacemodelica";}

plugin_options()

const Options & casadi::PluginInterface< ModelicaParserInternal >::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< ModelicaParserInternal >::Plugin casadi::PluginInterface< ModelicaParserInternal >::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;
  }

registerPlugin() [1/2]

void casadi::PluginInterface< ModelicaParserInternal >::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< ModelicaParserInternal >::registerPlugin ( RegFcn  regfcn, bool  needs_lock = true  )

staticinherited

Definition at line 99 of file plugin_interface.hpp.

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

serialize_type()

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

inlineinherited

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

Definition at line 117 of file plugin_interface.hpp.

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

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;
    }

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

infix_

const std::string casadi::ModelicaParserInternal::infix_ = "modelicaparser"

staticinherited

Definition at line 67 of file modelica_parser_internal.hpp.

meta_doc

const std::string casadi::LaceModelica::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"ModelicaParser using LaceModelica\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_2jx \n"
"\n"
"\n"

Definition at line 71 of file lace_modelica.hpp.

Referenced by casadi::casadi_register_modelicaparser_lacemodelica().

solvers_

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

staticinherited

Definition at line 60 of file modelica_parser_internal.hpp.

---

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

• lace_modelica.hpp
• lace_modelica.cpp
• lace_modelica_meta.cpp