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 #include <lua.h>
  28 #include <lauxlib.h>
  29
  30 typedef struct lua_class_property lua_class_property_t;
  31
  32 ARRAY_TYPE(lua_class_property_t, lua_class_property)
  33
  34 #define LUA_OBJECT_HEADER \
  35         signal_array_t signals;
  36
  37 /** Generic type for all objects.
  38  * All Lua objects can be casted to this type.
  39  */
  40 typedef struct
  41 {
  42     LUA_OBJECT_HEADER
  43 } lua_object_t;
  44
  45 typedef lua_object_t *(*lua_class_allocator_t)(lua_State *);
  46 typedef void (*lua_class_collector_t)(lua_object_t *);
  47
  48 typedef int (*lua_class_propfunc_t)(lua_State *, lua_object_t *);
  49
  50 typedef bool (*lua_class_checker_t)(lua_object_t *);
  51
  52 typedef struct lua_class_t lua_class_t;
  53 struct lua_class_t
  54 {
  55     /** Class name */
  56     const char *name;
  57     /** Class signals */
  58     signal_array_t signals;
  59     /** Parent class */
  60     lua_class_t *parent;
  61     /** Allocator for creating new objects of that class */
  62     lua_class_allocator_t allocator;
  63     /** Garbage collection function */
  64     lua_class_collector_t collector;
  65     /** Class properties */
  66     lua_class_property_array_t properties;
  67     /** Function to call when a indexing an unknown property */
  68     lua_class_propfunc_t index_miss_property;
  69     /** Function to call when a indexing an unknown property */
  70     lua_class_propfunc_t newindex_miss_property;
  71     /** Function to call to check if an object is valid */
  72     lua_class_checker_t checker;
  73     /** Number of instances of this class in lua */
  74     unsigned int instances;
  75 };
  76
  77 const char * luaA_typename(lua_State *, int);
  78 lua_class_t * luaA_class_get(lua_State *, int);
  79
  80 void luaA_class_connect_signal(lua_State *, lua_class_t *, const char *, lua_CFunction);
  81 void luaA_class_connect_signal_from_stack(lua_State *, lua_class_t *, const char *, int);
  82 void luaA_class_disconnect_signal_from_stack(lua_State *, lua_class_t *, const char *, int);
  83 void luaA_class_emit_signal(lua_State *, lua_class_t *, const char *, int);
  84
  85 void luaA_openlib(lua_State *, const char *, const struct luaL_Reg[], const struct luaL_Reg[]);
  86 void luaA_class_setup(lua_State *, lua_class_t *, const char *, lua_class_t *,
  87                       lua_class_allocator_t, lua_class_collector_t,
  88                       lua_class_checker_t,
  89                       lua_class_propfunc_t, lua_class_propfunc_t,
  90                       const struct luaL_Reg[], const struct luaL_Reg[]);
  91
  92 void luaA_class_add_property(lua_class_t *, const char *,
  93                              lua_class_propfunc_t, lua_class_propfunc_t, lua_class_propfunc_t);
  94
  95 int luaA_usemetatable(lua_State *, int, int);
  96 int luaA_class_index(lua_State *);
  97 int luaA_class_newindex(lua_State *);
  98 int luaA_class_new(lua_State *, lua_class_t *);
  99
 100 void * luaA_checkudata(lua_State *, int, lua_class_t *);
 101 void * luaA_toudata(lua_State *L, int ud, lua_class_t *);
 102
 103 static inline void *
 104 luaA_checkudataornil(lua_State *L, int udx, lua_class_t *class)
 105 {
 106     if(lua_isnil(L, udx))
 107         return NULL;
 108     return luaA_checkudata(L, udx, class);
 109 }
 110
 111 #define LUA_CLASS_FUNCS(prefix, lua_class) \
 112     static inline int                                                          \
 113     luaA_##prefix##_class_add_signal(lua_State *L)                             \
 114     {                                                                          \
 115         signal_add(&(lua_class).signals, luaL_checkstring(L, 1));              \
 116         return 0;                                                              \
 117     }                                                                          \
 118                                                                                \
 119     static inline int                                                          \
 120     luaA_##prefix##_class_connect_signal(lua_State *L)                         \
 121     {                                                                          \
 122         luaA_class_connect_signal_from_stack(L, &(lua_class),                  \
 123                                              luaL_checkstring(L, 1), 2);       \
 124         return 0;                                                              \
 125     }                                                                          \
 126                                                                                \
 127     static inline int                                                          \
 128     luaA_##prefix##_class_disconnect_signal(lua_State *L)                      \
 129     {                                                                          \
 130         luaA_class_disconnect_signal_from_stack(L, &(lua_class),               \
 131                                                 luaL_checkstring(L, 1), 2);    \
 132         return 0;                                                              \
 133     }                                                                          \
 134                                                                                \
 135     static inline int                                                          \
 136     luaA_##prefix##_class_emit_signal(lua_State *L)                            \
 137     {                                                                          \
 138         luaA_class_emit_signal(L, &(lua_class), luaL_checkstring(L, 1),        \
 139                                lua_gettop(L) - 1);                             \
 140         return 0;                                                              \
 141     }                                                                          \
 142                                                                                \
 143     static inline int                                                          \
 144     luaA_##prefix##_class_instances(lua_State *L)                              \
 145     {                                                                          \
 146         lua_pushnumber(L, (lua_class).instances);                              \
 147         return 1;                                                              \
 148     }
 149
 150 #define LUA_CLASS_METHODS(class) \
 151     { "add_signal", luaA_##class##_class_add_signal }, \
 152     { "connect_signal", luaA_##class##_class_connect_signal }, \
 153     { "disconnect_signal", luaA_##class##_class_disconnect_signal }, \
 154     { "emit_signal", luaA_##class##_class_emit_signal }, \
 155     { "instances", luaA_##class##_class_instances }, \
 156
 157 #define LUA_CLASS_META \
 158     { "__index", luaA_class_index }, \
 159     { "__newindex", luaA_class_newindex },
 160
 161 #endif
 162
 163 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80