src/lua/zip.cpp

   1 #include "library/zip.hpp"
   2 #include "lua/internal.hpp"
   3
   4 namespace
   5 {
   6         class lua_zip_writer
   7         {
   8         public:
   9                 lua_zip_writer(lua_state& L, const std::string& filename, unsigned compression);
  10                 ~lua_zip_writer()
  11                 {
  12                         if(w) delete w;
  13                 }
  14                 int commit(lua_state& L, const std::string& fname)
  15                 {
  16                         if(!w)
  17                                 throw std::runtime_error("Zip writer already finished");
  18                         if(file_open)
  19                                 w->close_file();
  20                         file_open = NULL;
  21                         w->commit();
  22                         delete w;
  23                         w = NULL;
  24                 }
  25                 int rollback(lua_state& L, const std::string& fname)
  26                 {
  27                         if(!w)
  28                                 throw std::runtime_error("Zip writer already finished");
  29                         delete w;
  30                         w = NULL;
  31                 }
  32                 int close_file(lua_state& L, const std::string& fname)
  33                 {
  34                         if(!w)
  35                                 throw std::runtime_error("Zip writer already finished");
  36                         if(!file_open)
  37                                 throw std::runtime_error("Zip writer doesn't have file open");
  38                         w->close_file();
  39                         file_open = NULL;
  40                 }
  41                 int create_file(lua_state& L, const std::string& fname)
  42                 {
  43                         if(!w)
  44                                 throw std::runtime_error("Zip writer already finished");
  45                         std::string filename = L.get_string(2, "ZIPWRITER::create_file");
  46                         if(file_open) {
  47                                 w->close_file();
  48                                 file_open = NULL;
  49                         }
  50                         file_open = &w->create_file(filename);
  51                 }
  52                 int write(lua_state& L, const std::string& fname)
  53                 {
  54                         if(!w)
  55                                 throw std::runtime_error("Zip writer already finished");
  56                         if(!file_open)
  57                                 throw std::runtime_error("Zip writer doesn't have file open");
  58                         std::string _data = L.get_string(2, "ZIPWRITER::write");
  59                         std::vector<char> data(_data.length());
  60                         std::copy(_data.begin(), _data.end(), data.begin());
  61                         file_open->write(&data[0], data.size());
  62                 }
  63                 std::string print()
  64                 {
  65                         return file;
  66                 }
  67         private:
  68                 zip::writer* w;
  69                 std::ostream* file_open;
  70                 std::string file;
  71         };
  72
  73         lua_class<lua_zip_writer> class_zipwriter("ZIPWRITER");
  74
  75         lua_zip_writer::lua_zip_writer(lua_state& L, const std::string& filename, unsigned compression)
  76         {
  77                 file = filename;
  78                 w = new zip::writer(filename, compression);
  79                 file_open = NULL;
  80                 objclass<lua_zip_writer>().bind_multi(L, {
  81                         {"commit", &lua_zip_writer::commit},
  82                         {"rollback", &lua_zip_writer::rollback},
  83                         {"close_file", &lua_zip_writer::close_file},
  84                         {"create_file", &lua_zip_writer::create_file},
  85                         {"write", &lua_zip_writer::write}
  86                 });
  87         }
  88
  89         function_ptr_luafun lua_zip(lua_func_zip, "zip.create", [](lua_state& L,
  90                 const std::string& fname) -> int {
  91                 unsigned compression = 9;
  92                 std::string filename = L.get_string(1, fname.c_str());
  93                 L.get_numeric_argument<unsigned>(2, compression, fname.c_str());
  94                 if(compression < 0)
  95                         compression = 0;
  96                 if(compression > 9)
  97                         compression = 9;
  98                 lua_class<lua_zip_writer>::create(L, filename, compression);
  99                 return 1;
 100         });
 101
 102         function_ptr_luafun lua_enumerate_zip(lua_func_zip, "zip.enumerate", [](lua_state& L,
 103                 const std::string& fname) -> int {
 104                 std::string filename = L.get_string(1, fname.c_str());
 105                 bool invert = false;
 106                 if(L.type(2) != LUA_TNONE && L.type(2) != LUA_TNIL)
 107                         invert = L.toboolean(2);
 108                 zip::reader r(filename);
 109                 L.newtable();
 110                 size_t idx = 1;
 111                 for(auto i : r) {
 112                         if(invert) {
 113                                 L.pushlstring(i);
 114                                 L.pushboolean(true);
 115                         } else {
 116                                 L.pushnumber(idx++);
 117                                 L.pushlstring(i);
 118                         }
 119                         L.rawset(-3);
 120                 }
 121                 return 1;
 122         });
 123 }