resource_internal.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_RESOURCE_INTERNAL_HPP
#define CASADI_RESOURCE_INTERNAL_HPP
 
#include "resource.hpp"
#include "shared_object.hpp"
#include "serializing_stream.hpp"
 
namespace casadi {
 
 
  class CASADI_EXPORT ResourceInternal : public SharedObjectInternal {
    public:
      explicit ResourceInternal();
      virtual const std::string& path() const = 0;
      void serialize(SerializingStream& s) const;
 
      virtual void serialize_type(SerializingStream& s) const;
      virtual void serialize_body(SerializingStream& s) const;
 
      static ResourceInternal* deserialize(DeserializingStream& s);
      void change_option(const std::string& option_name,
        const GenericType& option_value);
    protected:
      explicit ResourceInternal(DeserializingStream& s);
      std::string serialize_mode_;
  };
 
  class CASADI_EXPORT DirResource : public ResourceInternal {
    public:
      DirResource(const std::string& path);
      ~DirResource() override;
      const std::string& path() const override {return path_;}
 
      std::string class_name() const override {return "DirResource";}
 
      void disp(std::ostream& stream, bool more) const override;
 
      void serialize_type(SerializingStream& s) const override;
      void serialize_body(SerializingStream& s) const override;
 
      static ResourceInternal* deserialize(DeserializingStream& s);
    private:
      std::string path_;
    protected:
      explicit DirResource(DeserializingStream& s);
  };
 
  class CASADI_EXPORT TemporaryDirResource : public ResourceInternal {
    public:
      TemporaryDirResource(const std::string& base_name, const std::string& suffix="");
      ~TemporaryDirResource() override;
      const std::string& path() const override {return dir_;}
 
      std::string class_name() const override {return "TemporaryDirResource";}
 
      void disp(std::ostream& stream, bool more) const override;
    protected:
      explicit TemporaryDirResource() : ResourceInternal() {}
      explicit TemporaryDirResource(DeserializingStream& s) : ResourceInternal(s) {}
      void setup_temp_dir(const std::string& base_name, const std::string& suffix="");
      std::string lock_file_;
      std::string dir_;
  };
 
  class CASADI_EXPORT ZipResource : public TemporaryDirResource {
    public:
      ZipResource(const std::string& path);
 
      void unpack();
 
      std::string class_name() const override {return "ZipResource";}
 
      void disp(std::ostream& stream, bool more) const override;
 
      void serialize_type(SerializingStream& s) const override;
      void serialize_body(SerializingStream& s) const override;
 
      static ResourceInternal* deserialize(DeserializingStream& s);
    private:
      std::string path_;
    protected:
      explicit ZipResource(DeserializingStream& s);
  };
 
 
  class CASADI_EXPORT ZipMemResource : public TemporaryDirResource {
    public:
      ZipMemResource(const std::istream& src);
 
      void unpack();
      std::string class_name() const override {return "ZipMemResource";}
 
      void disp(std::ostream& stream, bool more) const override;
 
      void serialize_body(SerializingStream& s) const override;
 
      static ResourceInternal* deserialize(DeserializingStream& s);
    private:
      mutable std::stringstream blob_;
      #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      mutable std::mutex mutex_blob_;
      #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
    protected:
      explicit ZipMemResource(DeserializingStream& s);
  };
 
} // namespace casadi
#endif // CASADI_RESOURCE_INTERNAL_HPP