Add constructors for having memory-loaded jar files

This allows the jar_file class to load from a buffer (c array) as opposed to a file

Author: dcattaruzza

src/java_bytecode/jar_file.cpp

@@ -12,10 +12,7 @@ Author: Diffblue Ltd
 #include <util/invariant.h>
 #include "java_class_loader_limit.h"
 
-jar_filet::jar_filet(
-  java_class_loader_limitt &limit,
-  const std::string &filename):
-  m_zip_archive(filename)
+void jar_filet::initialize_file_index(java_class_loader_limitt &limit)
 {
   const size_t file_count=m_zip_archive.get_num_files();
   for(size_t index=0; index<file_count; index++)
@@ -26,6 +23,29 @@ jar_filet::jar_filet(
   }
 }
 
+/// This constructor creates a jar_file object whose contents
+/// are extracted from a memory buffer (byte array) as opposed
+/// to a jar file.
+jar_filet::jar_filet(
+  java_class_loader_limitt &limit,
+  const std::string &filename):
+  m_zip_archive(filename)
+{
+  initialize_file_index(limit);
+}
+
+/// This constructor creates a jar_file object whose contents
+/// are extracted from a memory buffer (byte array) as opposed
+/// to a jar file.
+jar_filet::jar_filet(
+  java_class_loader_limitt &limit,
+  const void *data,
+  size_t size):
+  m_zip_archive(data, size)
+{
+  initialize_file_index(limit);
+}
+
 // VS: No default move constructors or assigns
 
 jar_filet::jar_filet(jar_filet &&other):

src/java_bytecode/jar_file.h

@@ -21,16 +21,25 @@ class java_class_loader_limitt;
 class jar_filet final
 {
 public:
-  /// Open java file for reading
+  /// Open java file for reading.
   /// \param limit Object limiting number of loaded .class files
   /// \param filename Name of the file
   /// \throw Throws std::runtime_error if file cannot be opened
   jar_filet(java_class_loader_limitt &limit, const std::string &filename);
+
+  /// Open a JAR file of size \p size loaded in memory at address \p data.
+  /// \param limit Object limiting number of loaded .class files
+  /// \param data memory buffer with the contents of the jar file
+  /// \param size size  of the memory buffer
+  /// \throw Throws std::runtime_error if file cannot be opened
+  jar_filet(java_class_loader_limitt &limit, const void *data, size_t size);
+
   jar_filet(const jar_filet &)=delete;
   jar_filet &operator=(const jar_filet &)=delete;
   jar_filet(jar_filet &&);
   jar_filet &operator=(jar_filet &&);
   ~jar_filet()=default;
+
   /// Get contents of a file in the jar archive.
   /// Terminates the program if file doesn't exist
   /// \param filename Name of the file in the archive
@@ -40,8 +49,12 @@ class jar_filet final
   /// Get list of filenames in the archive
   std::vector<std::string> filenames() const;
 private:
+  /// Loads the fileindex (m_name_to_index) with a map of loaded files to
+  /// indices.
+  void initialize_file_index(java_class_loader_limitt &limit);
+
   mz_zip_archivet m_zip_archive;
-  /// Map of filename to the file index in the zip archive
+  /// Map of filename to the file index in the zip archive.
   std::unordered_map<std::string, size_t> m_name_to_index;
 };
 

src/java_bytecode/mz_zip_archive.cpp

@@ -25,6 +25,14 @@ class mz_zip_archive_statet final:public mz_zip_archive
     if(MZ_TRUE!=mz_zip_reader_init_file(this, filename.data(), 0))
       throw std::runtime_error("MZT: Could not load a file: "+filename);
   }
+
+  mz_zip_archive_statet(const void *data, size_t size):
+    mz_zip_archive({ })
+  {
+    if(MZ_TRUE!=mz_zip_reader_init_mem(this, data, size, 0))
+      throw std::runtime_error("MZT: Could not load data from memory");
+  }
+
   mz_zip_archive_statet(const mz_zip_archive_statet &)=delete;
   mz_zip_archive_statet(mz_zip_archive_statet &&)=delete;
   mz_zip_archive_statet &operator=(const mz_zip_archive_statet &)=delete;
@@ -41,6 +49,9 @@ static_assert(sizeof(mz_uint)<=sizeof(size_t),
 mz_zip_archivet::mz_zip_archivet(const std::string &filename):
   m_state(new mz_zip_archive_statet(filename)) { }
 
+mz_zip_archivet::mz_zip_archivet(const void *data, size_t size):
+  m_state(new mz_zip_archive_statet(data, size)) { }
+
 // VS Compatibility
 mz_zip_archivet::mz_zip_archivet(mz_zip_archivet &&other):
   m_state(std::move(other.m_state)) { }

src/java_bytecode/mz_zip_archive.h

@@ -24,6 +24,13 @@ class mz_zip_archivet final
   /// \param filename Path of the zip archive
   /// \throw Throws std::runtime_error if file cannot be opened
   explicit mz_zip_archivet(const std::string &filename);
+
+  /// Loads a zip buffer
+  /// \param data pointer to the memory buffer
+  /// \param size size of the buffer
+  /// \throw Throws std::runtime_error if file cannot be opened
+  mz_zip_archivet(const void *data, size_t size);
+
   mz_zip_archivet(const mz_zip_archivet &)=delete;
   mz_zip_archivet &operator=(const mz_zip_archivet &)=delete;
   /// Move constructor. Doesn't throw. Leaves other object invalidated.