'ghc' plugin for Filesystem More...

#include <ghc.hpp>

Detailed Description

Interface to ghc functionality

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

Author: Joris Gillis

Date: 2025

Definition at line 51 of file ghc.hpp.

Inheritance diagram for casadi::Ghc:

[legend]

Collaboration diagram for casadi::Ghc:

[legend]

Public Types
typedef bool(*	IsDirectory) (const std::string &path)

typedef bool(*	CreateDirectories) (const std::string &path)

typedef bool(*	Remove) (const std::string &path)

typedef casadi_int(*	RemoveAll) (const std::string &path)

typedef std::string(*	Filename) (const std::string &path)

typedef bool(*	HasParentPath) (const std::string &path)

typedef std::string(*	ParentPath) (const std::string &path)

typedef std::vector< std::string >(*	IterateDirectoryNames) (const std::string &path)

typedef std::string(*	Absolute) (const std::string &path)

typedef Filesystem (	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 void	assert_enabled ()

static bool	is_directory (const std::string &path)

static bool	remove (const std::string &path)

static casadi_int	remove_all (const std::string &path)

static std::string	filename (const std::string &path)

static bool	is_enabled ()

static bool	has_parent_path (const std::string &path)

static std::string	parent_path (const std::string &path)

static std::string	absolute (const std::string &path)

static bool	ensure_directory_exists (const std::string &path)

static bool	create_directories (const std::string &path)

static std::vector< std::string >	iterate_directory_names (const std::string &path)

static void	open (std::ofstream &, const std::string &path, std::ios_base::openmode mode=std::ios_base::out)

static std::ofstream *	ofstream_ptr (const std::string &path, std::ios_base::openmode mode=std::ios_base::out)

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 Filesystem *	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_ = "filesystem"
	Infix. More...

Member Typedef Documentation

◆ Absolute

typedef std::string(* casadi::Filesystem::Absolute) (const std::string &path)

inherited

Definition at line 55 of file filesystem_impl.hpp.

◆ CreateDirectories

typedef bool(* casadi::Filesystem::CreateDirectories) (const std::string &path)

inherited

Definition at line 48 of file filesystem_impl.hpp.

◆ Creator

typedef Filesystem*(* casadi::Filesystem::Creator) ()

inherited

Definition at line 58 of file filesystem_impl.hpp.

◆ Filename

typedef std::string(* casadi::Filesystem::Filename) (const std::string &path)

inherited

Definition at line 51 of file filesystem_impl.hpp.

◆ HasParentPath

typedef bool(* casadi::Filesystem::HasParentPath) (const std::string &path)

inherited

Definition at line 52 of file filesystem_impl.hpp.

◆ IsDirectory

typedef bool(* casadi::Filesystem::IsDirectory) (const std::string &path)

inherited

Definition at line 47 of file filesystem_impl.hpp.

◆ IterateDirectoryNames

typedef std::vector<std::string>(* casadi::Filesystem::IterateDirectoryNames) (const std::string &path)

inherited

Definition at line 54 of file filesystem_impl.hpp.

◆ ParentPath

typedef std::string(* casadi::Filesystem::ParentPath) (const std::string &path)

inherited

Definition at line 53 of file filesystem_impl.hpp.

◆ RegFcn

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

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ Remove

typedef bool(* casadi::Filesystem::Remove) (const std::string &path)

inherited

Definition at line 49 of file filesystem_impl.hpp.

◆ RemoveAll

typedef casadi_int(* casadi::Filesystem::RemoveAll) (const std::string &path)

inherited

Definition at line 50 of file filesystem_impl.hpp.

Member Function Documentation

◆ absolute()

std::string casadi::Filesystem::absolute ( const std::string & path )

staticinherited

Definition at line 78 of file filesystem.cpp.

                                                     {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.absolute(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::FmuInternal::finalize().

◆ assert_enabled()

void casadi::Filesystem::assert_enabled ( )

staticinherited

Definition at line 87 of file filesystem.cpp.

                                 {
   casadi_assert(Filesystem::is_enabled(),
   "This action requires advanced filesystem access. Compile CasADi with WITH_GC=ON.");
 }

References casadi::Filesystem::is_enabled().

Referenced by casadi::Filesystem::absolute(), casadi::Filesystem::create_directories(), casadi::extract_zip_internal(), casadi::Filesystem::filename(), casadi::Filesystem::has_parent_path(), casadi::Filesystem::is_directory(), casadi::Filesystem::iterate_directory_names(), casadi::Filesystem::parent_path(), casadi::Filesystem::remove(), and casadi::Filesystem::remove_all().

◆ create_directories()

bool casadi::Filesystem::create_directories ( const std::string & path )

staticinherited

Definition at line 63 of file filesystem.cpp.

                                                          {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.create_directories(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::Filesystem::ensure_directory_exists().

◆ deserialize()

static ProtoFunction* casadi::PluginInterface< Filesystem >::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);
     }

◆ ensure_directory_exists()

bool casadi::Filesystem::ensure_directory_exists ( const std::string & path )

staticinherited

Definition at line 105 of file filesystem.cpp.

                                                                   {
   if (has_parent_path(filename)) {
     std::string dir = parent_path(filename);
     if (!is_directory(dir)) {
       return create_directories(dir);
     }
   }
   return true;
 }

References casadi::Filesystem::create_directories(), casadi::Filesystem::filename(), casadi::Filesystem::has_parent_path(), casadi::Filesystem::is_directory(), and casadi::Filesystem::parent_path().

Referenced by casadi::Filesystem::open().

◆ filename()

std::string casadi::Filesystem::filename ( const std::string & path )

staticinherited

Definition at line 73 of file filesystem.cpp.

                                                     {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.filename(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::Filesystem::ensure_directory_exists(), casadi::Filesystem::open(), and casadi::ZipResource::unpack().

◆ getPlugin()

PluginInterface< Filesystem >::Plugin & casadi::PluginInterface< Filesystem >::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_parent_path()

bool casadi::Filesystem::has_parent_path ( const std::string & path )

staticinherited

Definition at line 53 of file filesystem.cpp.

                                                       {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.has_parent_path(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::Filesystem::ensure_directory_exists(), and casadi::DllLibrary::init_handle().

◆ has_plugin()

bool casadi::PluginInterface< Filesystem >::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()

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

◆ is_directory()

bool casadi::Filesystem::is_directory ( const std::string & path )

staticinherited

Definition at line 38 of file filesystem.cpp.

                                                    {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.is_directory(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::Filesystem::ensure_directory_exists(), and casadi::Resource::Resource().

◆ is_enabled()

bool casadi::Filesystem::is_enabled ( )

staticinherited

Definition at line 83 of file filesystem.cpp.

                             {
   return Filesystem::has_plugin("ghc");
 }

References casadi::PluginInterface< Filesystem >::has_plugin().

Referenced by casadi::Filesystem::assert_enabled(), casadi::FmuInternal::finalize(), casadi::DllLibrary::init_handle(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Filesystem::open(), casadi::Resource::Resource(), and casadi::ZipResource::unpack().

◆ iterate_directory_names()

std::vector< std::string > casadi::Filesystem::iterate_directory_names ( const std::string & path )

staticinherited

Definition at line 68 of file filesystem.cpp.

                                                                               {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.iterate_directory_names(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

◆ load_library()

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

◆ ofstream_ptr()

std::ofstream * casadi::Filesystem::ofstream_ptr	(	const std::string &	path,
		std::ios_base::openmode	mode = `std::ios_base::out`
	)

staticinherited

Definition at line 134 of file filesystem.cpp.

                             {
   std::ofstream* ret = new std::ofstream();
   Filesystem::open(*ret, path, mode);
   return ret;
 }

References casadi::Filesystem::open(), and casadi::path().

◆ open()

void casadi::Filesystem::open	(	std::ofstream &	stream,
		const std::string &	path,
		std::ios_base::openmode	mode = `std::ios_base::out`
	)

staticinherited

Definition at line 115 of file filesystem.cpp.

                               {
   if (is_enabled()) {
     casadi_assert(ensure_directory_exists(filename),
      "Unable to create the required directory for '" + filename + "'.");
   }
   stream.open(filename.c_str(), mode);
   if (is_enabled()) {
     casadi_assert(stream.good(),
       "Error opening stream '" + filename + "'.");
   } else {
     casadi_assert(stream.good(),
       "Error opening stream '" + filename + "'. "
       "Does the directory exits? "
       "Note that CasADi needs to be compiled with WITH_GC=ON "
       "for directories to be automatically created");
   }
 }

References casadi::Filesystem::ensure_directory_exists(), casadi::Filesystem::filename(), and casadi::Filesystem::is_enabled().

Referenced by casadi::conic_debug(), casadi::Function::export_code(), casadi::CodeGenerator::file_open(), casadi::FunctionInternal::generate_in(), casadi::Function::generate_in(), casadi::Function::generate_out(), casadi::FunctionInternal::generate_out(), casadi::FmuFunction::init(), casadi::Linsol::nfact(), casadi::Filesystem::ofstream_ptr(), and casadi::Sparsity::to_file().

◆ parent_path()

std::string casadi::Filesystem::parent_path ( const std::string & path )

staticinherited

Definition at line 58 of file filesystem.cpp.

                                                        {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.parent_path(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::Filesystem::ensure_directory_exists(), and casadi::DllLibrary::init_handle().

◆ plugin_deserialize()

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

pure virtualinherited

◆ plugin_options()

const Options & casadi::PluginInterface< Filesystem >::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< Filesystem >::Plugin casadi::PluginInterface< Filesystem >::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< Filesystem >::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< Filesystem >::registerPlugin	(	RegFcn	regfcn,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 99 of file plugin_interface.hpp.

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

◆ remove()

bool casadi::Filesystem::remove ( const std::string & path )

staticinherited

Definition at line 43 of file filesystem.cpp.

                                              {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.remove(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::ZipMemResource::~ZipMemResource(), and casadi::ZipResource::~ZipResource().

◆ remove_all()

casadi_int casadi::Filesystem::remove_all ( const std::string & path )

staticinherited

Definition at line 48 of file filesystem.cpp.

                                                        {
   assert_enabled();
   return Filesystem::getPlugin("ghc").exposed.remove_all(path);
 }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), and casadi::path().

Referenced by casadi::ZipMemResource::~ZipMemResource(), and casadi::ZipResource::~ZipResource().

◆ serialize_type()

void casadi::PluginInterface< Filesystem >::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::Filesystem::infix_ = "filesystem"

staticinherited

Definition at line 103 of file filesystem_impl.hpp.

◆ meta_doc

const std::string casadi::Ghc::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_2d0 \n"
"\n"
"\n"

Definition at line 54 of file ghc.hpp.

Referenced by casadi::casadi_register_filesystem_ghc().

◆ solvers_

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

staticinherited

Definition at line 76 of file filesystem_impl.hpp.

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

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Member Typedef Documentation

◆ Absolute

◆ CreateDirectories

◆ Creator

◆ Filename

◆ HasParentPath

◆ IsDirectory

◆ IterateDirectoryNames

◆ ParentPath

◆ RegFcn

◆ Remove

◆ RemoveAll

Member Function Documentation

◆ absolute()

◆ assert_enabled()

◆ create_directories()

◆ deserialize()

◆ ensure_directory_exists()

◆ filename()

◆ getPlugin()

◆ has_parent_path()

◆ has_plugin()

◆ instantiate()

◆ is_directory()

◆ is_enabled()

◆ iterate_directory_names()

◆ load_library()

◆ load_plugin()

◆ ofstream_ptr()

◆ open()

◆ parent_path()

◆ plugin_deserialize()

◆ plugin_name()

◆ plugin_options()

◆ pluginFromRegFcn()

◆ registerPlugin() [1/2]

◆ registerPlugin() [2/2]

◆ remove()

◆ remove_all()

◆ serialize_type()

Member Data Documentation

◆ infix_

◆ meta_doc

◆ solvers_