src/lua/zip.cpp

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