casadi::Archiver Class Reference

Archiver interface. More...

#include <archiver_impl.hpp>

Detailed Description

Zip and unzip archives without a core dependency

Author

Joris Gillis

Date

2025

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

Definition at line 45 of file archiver_impl.hpp.

Inheritance diagram for casadi::Archiver:

Collaboration diagram for casadi::Archiver:

Classes
struct	Exposed

Public Types
typedef bool(*	Unpack) (const std::string &src, const std::string &target_dir)
typedef bool(*	UnpackFromStringStream) (std::stringstream &src, const std::string &target_dir)
typedef bool(*	Pack) (const std::string &src_dir, const std::string &path)
typedef bool(*	PackToStream) (const std::string &src_dir, std::ostream &src)
typedef Archiver *(*	Creator) ()
typedef int(*	RegFcn) (Plugin *plugin)

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

Static Public Member Functions
static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...
static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...
static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...
static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...
static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...
static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...
static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...
static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...
static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...
static Archiver *	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
static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...
static const std::string	infix_ = "archiver"
	Infix. More...

Member Typedef Documentation

Creator

typedef Archiver*(* casadi::Archiver::Creator) ()

Definition at line 58 of file archiver_impl.hpp.

Pack

typedef bool(* casadi::Archiver::Pack) (const std::string &src_dir, const std::string &path)

Definition at line 52 of file archiver_impl.hpp.

PackToStream

typedef bool(* casadi::Archiver::PackToStream) (const std::string &src_dir, std::ostream &src)

Definition at line 54 of file archiver_impl.hpp.

RegFcn

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

inherited

Definition at line 73 of file plugin_interface.hpp.

Unpack

typedef bool(* casadi::Archiver::Unpack) (const std::string &src, const std::string &target_dir)

Definition at line 48 of file archiver_impl.hpp.

UnpackFromStringStream

typedef bool(* casadi::Archiver::UnpackFromStringStream) (std::stringstream &src, const std::string &target_dir)

Definition at line 50 of file archiver_impl.hpp.

Member Function Documentation

deserialize()

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

inlinestaticinherited

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

Definition at line 121 of file plugin_interface.hpp.

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

getPlugin()

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

instantiate()

Archiver * casadi::PluginInterface< Archiver >::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< Archiver >::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< Archiver >::Plugin casadi::PluginInterface< Archiver >::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< Archiver >::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()

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

pure virtualinherited

plugin_options()

const Options & casadi::PluginInterface< Archiver >::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< Archiver >::Plugin casadi::PluginInterface< Archiver >::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< Archiver >::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< Archiver >::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< Archiver >::serialize_type ( SerializingStream &  s ) const

inlineinherited

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

Definition at line 114 of file plugin_interface.hpp.

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

Member Data Documentation

infix_

const std::string casadi::Archiver::infix_ = "archiver"

static

Definition at line 78 of file archiver_impl.hpp.

meta_doc

const std::string casadi::Archiver::meta_doc

static

Definition at line 60 of file archiver_impl.hpp.

solvers_

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

static

Definition at line 71 of file archiver_impl.hpp.

---

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

• archiver_impl.hpp
• archiver.cpp