src/lua/callback.cpp

   1 #include "lua/internal.hpp"
   2 #include "library/minmax.hpp"
   3 #include <stdexcept>
   4
   5 namespace
   6 {
   7         class lua_callbacks_list
   8         {
   9         public:
  10                 lua_callbacks_list(lua::state& L);
  11                 static size_t overcommit() { return 0; }
  12                 static int create(lua::state& L, lua::parameters& P);
  13                 int index(lua::state& L, lua::parameters& P);
  14                 int newindex(lua::state& L, lua::parameters& P);
  15         };
  16
  17         class lua_callback_obj
  18         {
  19         public:
  20                 lua_callback_obj(lua::state& L, const std::string& name);
  21                 static size_t overcommit(const std::string& name) { return 0; }
  22                 int _register(lua::state& L, lua::parameters& P);
  23                 int _unregister(lua::state& L, lua::parameters& P);
  24                 int _call(lua::state& L, lua::parameters& P);
  25                 std::string print()
  26                 {
  27                         if(special == 1)
  28                                 return "global register";
  29                         else if(special == 2)
  30                                 return "global unregister";
  31                         else if(callback)
  32                                 return callback->get_name();
  33                         else
  34                                 return "(null)";
  35                 }
  36         private:
  37                 lua::state::callback_list* callback;
  38                 int special;
  39         };
  40
  41         lua::_class<lua_callbacks_list> LUA_class_callbacks_list(lua_class_callback, "CALLBACKS_LIST", {
  42                 {"new", lua_callbacks_list::create},
  43         }, {
  44                 {"__index", &lua_callbacks_list::index},
  45                 {"__newindex", &lua_callbacks_list::newindex},
  46         });
  47         lua::_class<lua_callback_obj> LUA_class_callback_obj(lua_class_callback, "CALLBACK_OBJ", {}, {
  48                 {"register", &lua_callback_obj::_register},
  49                 {"unregister", &lua_callback_obj::_unregister},
  50                 {"__call", &lua_callback_obj::_call},
  51         }, &lua_callback_obj::print);
  52
  53         lua_callbacks_list::lua_callbacks_list(lua::state& L)
  54         {
  55         }
  56
  57         int lua_callbacks_list::create(lua::state& L, lua::parameters& P)
  58         {
  59                 lua::_class<lua_callbacks_list>::create(L);
  60                 return 1;
  61         }
  62
  63         int lua_callbacks_list::index(lua::state& L, lua::parameters& P)
  64         {
  65                 std::string name;
  66
  67                 P(P.skipped(), name);
  68
  69                 lua::_class<lua_callback_obj>::create(L, name);
  70                 return 1;
  71         }
  72
  73         int lua_callbacks_list::newindex(lua::state& L, lua::parameters& P)
  74         {
  75                 throw std::runtime_error("Writing is not allowed");
  76         }
  77
  78         lua_callback_obj::lua_callback_obj(lua::state& L, const std::string& name)
  79         {
  80                 callback = NULL;
  81                 special = 0;
  82                 for(auto i : L.get_callbacks())
  83                         if(i->get_name() == name)
  84                                 callback = i;
  85                 if(name == "register") {
  86                         special = 1;
  87                         return;
  88                 }
  89                 if(name == "unregister") {
  90                         special = 2;
  91                         return;
  92                 }
  93                 if(!callback && !special)
  94                         throw std::runtime_error("Unknown callback type '" + name + "' for callback.<foo>");
  95         }
  96
  97         int lua_callback_obj::_register(lua::state& L, lua::parameters& P)
  98         {
  99                 int lfn;
 100
 101                 if(!callback) throw std::runtime_error(P.get_fname() + ": not valid");
 102
 103                 P(P.skipped(), P.function(lfn));
 104
 105                 L.pushvalue(lfn);
 106                 callback->_register(L);
 107                 L.pop(1);
 108                 L.pushvalue(lfn);
 109                 return 1;
 110         }
 111
 112         int lua_callback_obj::_unregister(lua::state& L, lua::parameters& P)
 113         {
 114                 int lfn;
 115
 116                 if(!callback) throw std::runtime_error(P.get_fname() + ": not valid");
 117
 118                 P(P.skipped(), P.function(lfn));
 119
 120                 L.pushvalue(lfn);
 121                 callback->_unregister(L);
 122                 L.pop(1);
 123                 L.pushvalue(lfn);
 124                 return 1;
 125         }
 126
 127         int lua_callback_obj::_call(lua::state& L, lua::parameters& P)
 128         {
 129                 std::string name;
 130                 int lfn;
 131
 132                 if(!special) throw std::runtime_error("Need to specify operation to do to callback");
 133
 134                 P(P.skipped(), name, P.function(lfn));
 135
 136                 bool any = false;
 137                 for(auto i : L.get_callbacks()) {
 138                         if(i->get_name() == name) {
 139                                 L.pushvalue(lfn);
 140                                 if(special == 1)
 141                                         i->_register(L);
 142                                 else if(special == 2)
 143                                         i->_unregister(L);
 144                                 L.pop(1);
 145                                 any = true;
 146                         }
 147                 }
 148                 if(!any)
 149                         throw std::runtime_error("Unknown callback type '" + name + "' for callback.register");
 150                 L.pushvalue(lfn);
 151                 return 1;
 152         }
 153 }