casadi::TinyXmlInterface Class Reference

'tinyxml' plugin for XmlFile More...

#include <tinyxml_interface.hpp>

Detailed Description

XmlFile using TinyXml

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

Definition at line 55 of file tinyxml_interface.hpp.

Inheritance diagram for casadi::TinyXmlInterface:

Collaboration diagram for casadi::TinyXmlInterface:

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

Public Member Functions
	TinyXmlInterface ()
const char *	plugin_name () const override
std::string	class_name () const override
	Readable name of the internal class. More...
XmlNode	parse (const std::string &filename) override
void	dump (const std::string &filename, const XmlNode &node) override
XmlNode	import_node (TiXmlNode *n)
void	export_node (TiXmlNode *n, const XmlNode &node)
	~TinyXmlInterface () 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...
void	serialize_type (SerializingStream &s) const
	Serialize type information. More...

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

Public Attributes
TiXmlDocument	doc_
	XML file. 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_ = "xmlfile"
	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 XmlFileInternal*(* casadi::XmlFileInternal::Creator) ()

inherited

Definition at line 57 of file xml_file_internal.hpp.

RegFcn

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

TinyXmlInterface()

casadi::TinyXmlInterface::TinyXmlInterface

(

)

Definition at line 45 of file tinyxml_interface.cpp.

                                    {
}

~TinyXmlInterface()

casadi::TinyXmlInterface::~TinyXmlInterface ( )

override

Definition at line 48 of file tinyxml_interface.cpp.

                                    {
}

Member Function Documentation

class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 69 of file tinyxml_interface.hpp.

{ return "TinyXmlInterface";}

creator()

static XmlFileInternal* casadi::TinyXmlInterface::creator ( )

inlinestatic

Definition at line 62 of file tinyxml_interface.hpp.

    { return new TinyXmlInterface();}

Referenced by casadi::casadi_register_xmlfile_tinyxml().

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

deserialize()

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

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

overridevirtualinherited

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

Implements casadi::SharedObjectInternal.

Definition at line 44 of file xml_file_internal.cpp.

                                                              {
}

dump()

void casadi::TinyXmlInterface::dump ( const std::string &  filename, const XmlNode &  node  )

overridevirtual

Reimplemented from casadi::XmlFileInternal.

Definition at line 65 of file tinyxml_interface.cpp.

                                                                          {
  // Add encoding declaration
  doc_.InsertEndChild(doc_.NewDeclaration());
  // Export from CasADi representation
  try {
    export_node(&doc_, node);
  } catch (std::exception& e) {
    casadi_error("Cannot export " + filename + ": " + std::string(e.what()));
  }
  // Save XML file to disk
  XMLError err = doc_.SaveFile(filename.c_str());
  casadi_assert(!err, "Cannot save " + filename);
}

References doc_, export_node(), and casadi::filename().

export_node()

void casadi::TinyXmlInterface::export_node	(	TiXmlNode *	n,
		const XmlNode &	node
	)

Definition at line 130 of file tinyxml_interface.cpp.

                                                                    {
    // Loop over children
    for (const XmlNode& c : node.children) {
      // Create new node for the child
      TiXmlElement* tc = doc_.NewElement(c.name.c_str());
      n->InsertEndChild(tc);
      // Save all attributes
      for (auto&& a : c.attributes) {
        tc->SetAttribute(a.first.c_str(), a.second.c_str());
      }
      // Add (grand)children, if any
      export_node(tc, c);
    }
}

References casadi::XmlNode::attributes, casadi::XmlNode::children, doc_, and casadi::XmlNode::name.

Referenced by dump().

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< XmlFileInternal >::Plugin & casadi::PluginInterface< XmlFileInternal >::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< XmlFileInternal >::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_node()

XmlNode casadi::TinyXmlInterface::import_node

(

TiXmlNode *

n

)

Definition at line 79 of file tinyxml_interface.cpp.

                                                  {
  if (!n) casadi_error("Node is 0");
  XmlNode ret;
 
  ret.line = n->GetLineNum();
 
  // Save name
  if (n->Value()) {
    ret.name = n->Value();
  }
 
  // Save attributes
  if (n->ToElement()) {
    for (const TiXmlAttribute* pAttrib=n->ToElement()->FirstAttribute();
                                pAttrib; pAttrib=pAttrib->Next()) {
      ret.set_attribute(pAttrib->Name(), pAttrib->Value());
    }
  } else if (n->ToDocument()) {
    // do nothing
  } else {
    casadi_error("TinyXmlInterface::import_node");
  }
 
  // Count the number of children
  casadi_int num_children = 0;
  for (TiXmlNode* child = n->FirstChild(); child != nullptr; child = child->NextSibling()) {
    num_children++;
  }
  ret.children.reserve(num_children);
 
  // add children
  for (TiXmlNode* child = n->FirstChild(); child != nullptr; child = child->NextSibling()) {
    if (child->ToElement()) {
      ret.children.push_back(import_node(child));
    } else if (child->ToComment()) {
      ret.comment = child->Value();
    } else if (child->ToText()) {
      ret.text = child->ToText()->Value();
    } else if (child->ToDeclaration()) {
      // pass
    } else if (child->ToDocument()) {
      // pass
    } else {
      casadi_error("Unknown node type");
    }
  }
 
  // Note: Return value optimization
  return ret;
}

References casadi::XmlNode::children, casadi::XmlNode::comment, casadi::XmlNode::line, casadi::XmlNode::name, casadi::XmlNode::set_attribute(), and casadi::XmlNode::text.

Referenced by parse().

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

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

XmlNode casadi::TinyXmlInterface::parse ( const std::string &  filename )

overridevirtual

Reimplemented from casadi::XmlFileInternal.

Definition at line 51 of file tinyxml_interface.cpp.

                                                         {
  // Load XML file from disk
  XMLError err = doc_.LoadFile(filename.c_str());
  casadi_assert(!err, "Cannot load " + filename);
  // Import to CasADi representation
  XmlNode n;
  try {
    n = import_node(&doc_);
  } catch (std::exception& e) {
    casadi_error("Cannot import " + filename + ": " + std::string(e.what()));
  }
  return n;
}

References doc_, casadi::filename(), and import_node().

plugin_deserialize()

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

inlineoverridevirtual

Implements casadi::PluginInterface< XmlFileInternal >.

Definition at line 66 of file tinyxml_interface.hpp.

{ return "tinyxml";}

plugin_options()

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

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.

                                                                                  {
    if (weak_ref_==nullptr) {
      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
    }
    return weak_ref_;
  }

Member Data Documentation

doc_

TiXmlDocument casadi::TinyXmlInterface::doc_

Definition at line 90 of file tinyxml_interface.hpp.

Referenced by dump(), export_node(), and parse().

infix_

const std::string casadi::XmlFileInternal::infix_ = "xmlfile"

staticinherited

Definition at line 70 of file xml_file_internal.hpp.

meta_doc

const std::string casadi::TinyXmlInterface::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"XmlFile using TinyXml\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_22i \n"
"\n"
"\n"

Definition at line 87 of file tinyxml_interface.hpp.

Referenced by casadi::casadi_register_xmlfile_tinyxml().

solvers_

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

staticinherited

Definition at line 63 of file xml_file_internal.hpp.

---

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

• tinyxml_interface.hpp
• tinyxml_interface.cpp
• tinyxml_interface_meta.cpp