casadi::GraphModelInternal Class Reference

Base interface for format-specific graph-model backends. More...

#include <graph_model_internal.hpp>

Detailed Description

Subclasses (e.g. Onnx) own the heavy dependency and implement metadata fill, symbolic import and symbolic export. Registered as plugins by format name.

Date

2026

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

Definition at line 47 of file graph_model_internal.hpp.

Inheritance diagram for casadi::GraphModelInternal:

Collaboration diagram for casadi::GraphModelInternal:

Classes
struct	Exposed
	No statically-exposed plugin functions. More...

Public Types
typedef GraphModelInternal *(*	Creator) (const std::vector< uint8_t > &model_data)
	Plugin creator function type. More...
using	weak_ref_type = WeakRefInternal
typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	GraphModelInternal (const std::vector< uint8_t > &model_data)
	~GraphModelInternal () override
std::string	class_name () const override
	Readable name of the internal class. More...
void	disp (std::ostream &stream, bool more) const override
	Print a description of the object. More...
void	construct (const Dict &opts)
	Prepare the backend for use. More...
virtual void	init (const Dict &opts)
	Initialize. More...
virtual void	fill_metadata (GraphBuilderInternal &gb) const =0
	Populate a builder's Node metadata from the parsed model. More...
virtual Function	import_symbolic (const GraphBuilderInternal &gb, const std::string &name)=0
	Rebuild the graph as a CasADi Function (symbolic import; mutates the backend's engine) More...
virtual std::vector< uint8_t >	export_symbolic (const Function &f, const Dict &opts)=0
	Serialize a CasADi Function as model bytes (symbolic export; mutates the backend's engine) More...
const std::vector< uint8_t > &	model_data () const
	Raw model bytes. More...
const char *	plugin_name () const override=0
	Query plugin name. 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 std::string	shortname ()
	Short name. 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 GraphModelInternal *	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 std::map< std::string, Plugin >	solvers_
	Collection of available format plugins. More...
static const std::string	infix_ = "graphmodel"
	Infix used to form plugin registration symbols (casadi_register_graphmodel_<name>) 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...

Protected Attributes
std::vector< uint8_t >	model_data_
	Raw model bytes (empty when constructed for export only) More...
bool	verbose_
	Verbose – for debugging. More...
static const Options	options_
	Options. More...
virtual const Options &	get_options () const
	Options. More...

Member Typedef Documentation

Creator

typedef GraphModelInternal*(* casadi::GraphModelInternal::Creator) (const std::vector< uint8_t > &model_data)

Definition at line 58 of file graph_model_internal.hpp.

RegFcn

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

GraphModelInternal()

casadi::GraphModelInternal::GraphModelInternal ( const std::vector< uint8_t > &  model_data )

explicit

Definition at line 83 of file graph_model.cpp.

    : model_data_(model_data), verbose_(false) {
  }

~GraphModelInternal()

casadi::GraphModelInternal::~GraphModelInternal ( )

override

Definition at line 87 of file graph_model.cpp.

                                          {
  }

Member Function Documentation

class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Reimplemented in casadi::Onnx.

Definition at line 54 of file graph_model_internal.hpp.

{ return "GraphModelInternal"; }

construct()

void casadi::GraphModelInternal::construct

(

const Dict &

opts

)

Definition at line 96 of file graph_model.cpp.

                                                     {
    for (auto&& op : opts) {
      if (op.first == "verbose") verbose_ = op.second;
    }
    init(opts);
  }

References init(), and verbose_.

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

inlinevirtualinherited

Definition at line 112 of file plugin_interface.hpp.

{}

deserialize()

static ProtoFunction* casadi::PluginInterface< GraphModelInternal >::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::GraphModelInternal::disp ( std::ostream &  stream, bool  more  ) const

overridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 106 of file graph_model.cpp.

                                                                   {
    stream << "GraphModel(" << plugin_name() << ")";
  }

References plugin_name().

export_symbolic()

virtual std::vector<uint8_t> casadi::GraphModelInternal::export_symbolic ( const Function &  f, const Dict &  opts  )

pure virtual

Implemented in casadi::Onnx.

fill_metadata()

virtual void casadi::GraphModelInternal::fill_metadata ( GraphBuilderInternal &  gb ) const

pure virtual

Implemented in casadi::Onnx.

get_options()

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

inlinevirtual

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

Reimplemented in casadi::Onnx.

Definition at line 68 of file graph_model_internal.hpp.

{ return options_; }

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< GraphModelInternal >::Plugin & casadi::PluginInterface< GraphModelInternal >::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< GraphModelInternal >::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;
    }
  }

import_symbolic()

virtual Function casadi::GraphModelInternal::import_symbolic ( const GraphBuilderInternal &  gb, const std::string &  name  )

pure virtual

Implemented in casadi::Onnx.

Referenced by casadi::GraphModel::import_symbolic().

init()

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

virtual

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

Reimplemented in casadi::Onnx.

Definition at line 103 of file graph_model.cpp.

                                                {
  }

Referenced by construct(), and casadi::Onnx::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++;
    }

instantiate()

GraphModelInternal * casadi::PluginInterface< GraphModelInternal >::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< GraphModelInternal >::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< GraphModelInternal >::Plugin casadi::PluginInterface< GraphModelInternal >::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
  }

model_data()

const std::vector<uint8_t>& casadi::GraphModelInternal::model_data ( ) const

inline

Definition at line 90 of file graph_model_internal.hpp.

{ return model_data_; }

Referenced by casadi::Onnx::Onnx().

plugin_deserialize()

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

overridepure virtual

Implements casadi::PluginInterface< GraphModelInternal >.

Implemented in casadi::Onnx.

Referenced by disp().

plugin_options()

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

shortname()

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

inlinestatic

Definition at line 106 of file graph_model_internal.hpp.

{ return "graphmodel"; }

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::GraphModelInternal::infix_ = "graphmodel"

static

Definition at line 103 of file graph_model_internal.hpp.

model_data_

std::vector<uint8_t> casadi::GraphModelInternal::model_data_

protected

Definition at line 110 of file graph_model_internal.hpp.

options_

const Options casadi::GraphModelInternal::options_

static

Initial value:

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

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

Definition at line 67 of file graph_model_internal.hpp.

solvers_

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

static

Definition at line 96 of file graph_model_internal.hpp.

verbose_

bool casadi::GraphModelInternal::verbose_

protected

Definition at line 113 of file graph_model_internal.hpp.

Referenced by construct(), casadi::Onnx::load(), and casadi::Onnx::set_dimension().

---

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

• graph_model_internal.hpp
• graph_model.cpp