casadi::ZipResource Class Reference

RAII class for reading from a zip file. More...

#include <resource_internal.hpp>

Detailed Description

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

Definition at line 126 of file resource_internal.hpp.

Inheritance diagram for casadi::ZipResource:

Collaboration diagram for casadi::ZipResource:

Public Types
using	weak_ref_type = WeakRefInternal

Public Member Functions
	ZipResource (const std::string &path)
	Initialize with a path. More...
void	unpack ()
std::string	class_name () const override
	Get type name. More...
void	disp (std::ostream &stream, bool more) const override
	Print description. More...
void	serialize_type (SerializingStream &s) const override
	Potentially decay into ZipMemResource. More...
void	serialize_body (SerializingStream &s) const override
const std::string &	path () const override
	Get path for a consumer. More...
void	serialize (SerializingStream &s) const
void	change_option (const std::string &option_name, const GenericType &option_value)
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...

Static Public Member Functions
static ResourceInternal *	deserialize (DeserializingStream &s)

Protected Member Functions
	ZipResource (DeserializingStream &s)
void	setup_temp_dir (const std::string &base_name, const std::string &suffix="")
	Set up lock file and directory paths from a base name. More...
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::string	lock_file_
std::string	dir_
std::string	serialize_mode_

Member Typedef Documentation

weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

ZipResource() [1/2]

casadi::ZipResource::ZipResource

(

const std::string &

path

)

The zip file is extracted to a temporary directory.

Upon destruction, the temporary directory is removed.

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

Definition at line 96 of file resource_internal.cpp.

    : TemporaryDirResource() {
  path_ = path;
  unpack();
}

References casadi::TemporaryDirResource::path(), and unpack().

Referenced by deserialize().

ZipResource() [2/2]

casadi::ZipResource::ZipResource ( DeserializingStream &  s )

explicitprotected

Definition at line 198 of file resource_internal.cpp.

                                               : TemporaryDirResource(s) {
  s.version("ZipResource", 1);
  s.unpack("ZipResource::path", path_);
  unpack();
}

References unpack(), casadi::DeserializingStream::unpack(), and casadi::DeserializingStream::version().

Member Function Documentation

change_option()

void casadi::ResourceInternal::change_option ( const std::string &  option_name, const GenericType &  option_value  )

inherited

Definition at line 53 of file resource_internal.cpp.

                                     {
  if (option_name=="serialize_mode") {
    serialize_mode_ = option_value.to_string();
    casadi_assert(serialize_mode_=="embed" || serialize_mode_=="link",
      "Invalid serialization mode: " + serialize_mode_ + ". Pick 'link' or 'embed'.");
  } else {
    casadi_error("Option '" + option_name + "' does not exist");
  }
}

References casadi::ResourceInternal::serialize_mode_, and casadi::GenericType::to_string().

class_name()

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

inlineoverridevirtual

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

Reimplemented from casadi::TemporaryDirResource.

Definition at line 142 of file resource_internal.hpp.

{return "ZipResource";}

Referenced by serialize_type().

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

ResourceInternal * casadi::ZipResource::deserialize ( DeserializingStream &  s )

static

Definition at line 183 of file resource_internal.cpp.

                                                                 {
  ZipResource* ret = new ZipResource(s);
  return ret;
}

References ZipResource().

Referenced by casadi::ResourceInternal::deserialize().

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

overridevirtual

Reimplemented from casadi::TemporaryDirResource.

Definition at line 108 of file resource_internal.cpp.

                                                          {
  stream << "ZipResource(\"" << path_ << "\") -> \"" << dir_ << "\"";
}

References casadi::TemporaryDirResource::dir_.

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

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

path()

const std::string& casadi::TemporaryDirResource::path ( ) const

inlineoverridevirtualinherited

Implements casadi::ResourceInternal.

Definition at line 105 of file resource_internal.hpp.

{return dir_;}

Referenced by casadi::open_resource(), and ZipResource().

serialize()

void casadi::ResourceInternal::serialize ( SerializingStream &  s ) const

inherited

Definition at line 149 of file resource_internal.cpp.

                                                           {
  s.version("ResourceInternal", 1);
  serialize_type(s);
  serialize_body(s);
}

References casadi::ResourceInternal::serialize_body(), casadi::ResourceInternal::serialize_type(), and casadi::SerializingStream::version().

serialize_body()

void casadi::ZipResource::serialize_body ( SerializingStream &  s ) const

overridevirtual

Reimplemented from casadi::ResourceInternal.

Definition at line 245 of file resource_internal.cpp.

                                                           {
  ResourceInternal::serialize_body(s);
  s.version("ZipResource", 1);
  if (serialize_mode_=="embed") {
    // Decay into ZipMemResource
    auto binary_ptr = Filesystem::ifstream_ptr(path_, std::ios_base::binary, false);
    casadi_assert(binary_ptr,
      "Could not open zip file '" + path_ + "'.");
    s.pack("ZipMemResource::blob", *binary_ptr);
  } else {
    s.pack("ZipResource::path", path_);
  }
}

References casadi::Filesystem::ifstream_ptr(), casadi::SerializingStream::pack(), casadi::ResourceInternal::serialize_body(), casadi::ResourceInternal::serialize_mode_, and casadi::SerializingStream::version().

serialize_type()

void casadi::ZipResource::serialize_type ( SerializingStream &  s ) const

overridevirtual

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

Reimplemented from casadi::ResourceInternal.

Definition at line 218 of file resource_internal.cpp.

                                                           {
  if (serialize_mode_=="embed") {
    // Decay into ZipMemResource
    std::string class_name = "ZipMemResource";
    s.pack("ResourceInternal::type", class_name);
  } else if (serialize_mode_=="link") {
    std::string class_name = "ZipResource";
    s.pack("ResourceInternal::type", class_name);
  } else {
    casadi_error("Unknown serialization mode: '" + serialize_mode_+ "'.");
  }
}

References class_name(), casadi::SerializingStream::pack(), and casadi::ResourceInternal::serialize_mode_.

setup_temp_dir()

void casadi::TemporaryDirResource::setup_temp_dir ( const std::string &  base_name, const std::string &  suffix = ""  )

protectedinherited

Definition at line 116 of file resource_internal.cpp.

                                                                                             {
  // Resolve absolute path since cwd may be changed by the user
  lock_file_ = Filesystem::absolute(temporary_file(base_name + ".", ".lock"));
  dir_ = lock_file_.substr(0, lock_file_.size() - 5);
  if (!suffix.empty()) {
    dir_ += "." + suffix;
  }
  // Create the directory
  Filesystem::create_directories(dir_);
}

References casadi::Filesystem::absolute(), casadi::Filesystem::create_directories(), casadi::TemporaryDirResource::dir_, casadi::TemporaryDirResource::lock_file_, and casadi::temporary_file().

Referenced by casadi::TemporaryDirResource::TemporaryDirResource(), unpack(), and casadi::ZipMemResource::unpack().

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

unpack()

void casadi::ZipResource::unpack

(

)

Definition at line 64 of file resource_internal.cpp.

                         {
  casadi_assert(Filesystem::is_enabled(),
  "Unzipping '" + path_ + "' requires advanced filesystem access. "
  "Compile CasADi with WITH_GHC_FILESYSTEM=ON.\n"
  "Alternatively, manually unzip it into a direcory, "
  "and pass this directory name instead of the zip file name.");
 
  // Set up temporary directory
  setup_temp_dir(Filesystem::filename(path_), "unzipped");
 
  casadi_assert(Archiver::has_plugin("libzip"),
  "Unzipping '" + path_ + "' requires libzip. Compile CasADi with WITH_LIBZIP=ON.\n"
  "Alternatively, manually unzip it into a direcory, "
  "and pass this directory name instead of the zip file name.");
 
  Archiver::getPlugin("libzip").exposed.unpack(path_, dir_);
}

References casadi::TemporaryDirResource::dir_, casadi::Filesystem::filename(), casadi::PluginInterface< Archiver >::getPlugin(), casadi::PluginInterface< Archiver >::has_plugin(), casadi::Filesystem::is_enabled(), and casadi::TemporaryDirResource::setup_temp_dir().

Referenced by ZipResource().

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

dir_

std::string casadi::TemporaryDirResource::dir_

protectedinherited

Definition at line 120 of file resource_internal.hpp.

Referenced by casadi::TemporaryDirResource::disp(), disp(), casadi::ZipMemResource::disp(), casadi::TemporaryDirResource::setup_temp_dir(), unpack(), casadi::ZipMemResource::unpack(), and casadi::TemporaryDirResource::~TemporaryDirResource().

lock_file_

std::string casadi::TemporaryDirResource::lock_file_

protectedinherited

Definition at line 119 of file resource_internal.hpp.

Referenced by casadi::TemporaryDirResource::setup_temp_dir(), and casadi::TemporaryDirResource::~TemporaryDirResource().

serialize_mode_

std::string casadi::ResourceInternal::serialize_mode_

protectedinherited

Definition at line 63 of file resource_internal.hpp.

Referenced by casadi::ResourceInternal::change_option(), casadi::ResourceInternal::ResourceInternal(), casadi::ResourceInternal::serialize_body(), casadi::DirResource::serialize_body(), serialize_body(), casadi::DirResource::serialize_type(), and serialize_type().

---

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

• resource_internal.hpp
• resource_internal.cpp