common/luaclass.h

   1 /*
   2  * luaclass.h - useful functions for handling Lua classes
   3  *
   4  * Copyright © 2009 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #ifndef AWESOME_COMMON_LUACLASS
  23 #define AWESOME_COMMON_LUACLASS
  24
  25 #include "common/signal.h"
  26
  27 typedef struct lua_class_property lua_class_property_t;
  28
  29 ARRAY_TYPE(lua_class_property_t, lua_class_property)
  30
  31 #define LUA_OBJECT_HEADER \
  32         signal_array_t signals;
  33
  34 /** Generic type for all objects.
  35  * All Lua objects can be casted to this type.
  36  */
  37 typedef struct
  38 {
  39     LUA_OBJECT_HEADER
  40 } lua_object_t;
  41
  42 typedef lua_object_t *(*lua_class_allocator_t)(lua_State *);
  43 typedef void (*lua_class_collector_t)(lua_object_t *);
  44
  45 typedef int (*lua_class_propfunc_t)(lua_State *, lua_object_t *);
  46
  47 typedef bool (*lua_class_checker_t)(lua_object_t *);
  48
  49 typedef struct lua_class_t lua_class_t;
  50 struct lua_class_t
  51 {
  52     /** Class name */
  53     const char *name;
  54     /** Class signals */
  55     signal_array_t signals;
  56     /** Parent class */
  57     lua_class_t *parent;
  58     /** Allocator for creating new objects of that class */
  59     lua_class_allocator_t allocator;
  60     /** Garbage collection function */
  61     lua_class_collector_t collector;
  62     /** Class properties */
  63     lua_class_property_array_t properties;
  64     /** Function to call when a indexing an unknown property */
  65     lua_class_propfunc_t index_miss_property;
  66     /** Function to call when a indexing an unknown property */
  67     lua_class_propfunc_t newindex_miss_property;
  68     /** Function to call to check if an object is valid */
  69     lua_class_checker_t checker;
  70     /** Number of instances of this class in lua */
  71     unsigned int instances;
  72 };
  73
  74 const char * luaA_typename(lua_State *, int);
  75 lua_class_t * luaA_class_get(lua_State *, int);
  76
  77 void luaA_class_connect_signal(lua_State *, lua_class_t *, const char *, lua_CFunction);
  78 void luaA_class_connect_signal_from_stack(lua_State *, lua_class_t *, const char *, int);
  79 void luaA_class_disconnect_signal_from_stack(lua_State *, lua_class_t *, const char *, int);
  80 void luaA_class_emit_signal(lua_State *, lua_class_t *, const char *, int);
  81
  82 void luaA_openlib(lua_State *, const char *, const struct luaL_Reg[], const struct luaL_Reg[]);
  83 void luaA_class_setup(lua_State *, lua_class_t *, const char *, lua_class_t *,
  84                       lua_class_allocator_t, lua_class_collector_t,
  85                       lua_class_checker_t,
  86                       lua_class_propfunc_t, lua_class_propfunc_t,
  87                       const struct luaL_Reg[], const struct luaL_Reg[]);
  88
  89 void luaA_class_add_property(lua_class_t *, const char *,
  90                              lua_class_propfunc_t, lua_class_propfunc_t, lua_class_propfunc_t);
  91
  92 int luaA_usemetatable(lua_State *, int, int);
  93 int luaA_class_index(lua_State *);
  94 int luaA_class_newindex(lua_State *);
  95 int luaA_class_new(lua_State *, lua_class_t *);
  96
  97 void * luaA_checkudata(lua_State *, int, lua_class_t *);
  98 void * luaA_toudata(lua_State *L, int ud, lua_class_t *);
  99
 100 static inline void *
 101 luaA_checkudataornil(lua_State *L, int udx, lua_class_t *class)
 102 {
 103     if(lua_isnil(L, udx))
 104         return NULL;
 105     return luaA_checkudata(L, udx, class);
 106 }
 107
 108 #define LUA_CLASS_FUNCS(prefix, lua_class) \
 109     static inline int                                                          \
 110     luaA_##prefix##_class_add_signal(lua_State *L)                             \
 111     {                                                                          \
 112         signal_add(&(lua_class).signals, luaL_checkstring(L, 1));              \
 113         return 0;                                                              \
 114     }                                                                          \
 115                                                                                \
 116     static inline int                                                          \
 117     luaA_##prefix##_class_connect_signal(lua_State *L)                         \
 118     {                                                                          \
 119         luaA_class_connect_signal_from_stack(L, &(lua_class),                  \
 120                                              luaL_checkstring(L, 1), 2);       \
 121         return 0;                                                              \
 122     }                                                                          \
 123                                                                                \
 124     static inline int                                                          \
 125     luaA_##prefix##_class_disconnect_signal(lua_State *L)                      \
 126     {                                                                          \
 127         luaA_class_disconnect_signal_from_stack(L, &(lua_class),               \
 128                                                 luaL_checkstring(L, 1), 2);    \
 129         return 0;                                                              \
 130     }                                                                          \
 131                                                                                \
 132     static inline int                                                          \
 133     luaA_##prefix##_class_emit_signal(lua_State *L)                            \
 134     {                                                                          \
 135         luaA_class_emit_signal(L, &(lua_class), luaL_checkstring(L, 1),        \
 136                                lua_gettop(L) - 1);                             \
 137         return 0;                                                              \
 138     }                                                                          \
 139                                                                                \
 140     static inline int                                                          \
 141     luaA_##prefix##_class_instances(lua_State *L)                              \
 142     {                                                                          \
 143         lua_pushnumber(L, (lua_class).instances);                              \
 144         return 1;                                                              \
 145     }
 146
 147 #define LUA_CLASS_METHODS(class) \
 148     { "add_signal", luaA_##class##_class_add_signal }, \
 149     { "connect_signal", luaA_##class##_class_connect_signal }, \
 150     { "disconnect_signal", luaA_##class##_class_disconnect_signal }, \
 151     { "emit_signal", luaA_##class##_class_emit_signal }, \
 152     { "instances", luaA_##class##_class_instances }, \
 153
 154 #define LUA_CLASS_META \
 155     { "__index", luaA_class_index }, \
 156     { "__newindex", luaA_class_newindex },
 157
 158 #endif
 159
 160 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80