Object Properties

wiki

Some object-orientated languages (like [C#]) support properties, which appear like public data fields on objects but are really syntactic sugar for accessor functions (getters and setters). In Lua it might look like this:

obj.field = 123 -- equivalent to obj:set_field(123)
x = obj.field -- equivalent to x = obj:get_field()

Here is one way to implement such a thing in Lua:

-- Make proxy object with property support.
-- Notes:
-- If key is found in <getters> (or <setters>), then
-- corresponding function is used, else lookup turns to the
-- <class> metatable (or first to <priv> if <is_expose_private> is true).
-- Given a proxy object <self>, <priv> can be obtained with
-- getmetatable(self).priv .
-- @param class - metatable acting as the object class.
-- @param priv - table containing private data for object.
-- @param getters - table of getter functions
-- with keys as property names. (default is nil)
-- @param setters - table of setter functions,
-- with keys as property names. (default is nil)
-- @param is_expose_private - Boolean whether to expose <priv> through proxy.
-- (default is nil/false)
-- @version 3 - 20060921 (D.Manura)
local function make_proxy(class, priv, getters, setters, is_expose_private)
 setmetatable(priv, class) -- fallback priv lookups to class
 local fallback = is_expose_private and priv or class
 local index = getters and
 function(self, key)
 -- read from getter, else from fallback
 local func = getters[key]
 if func then return func(self) else return fallback[key] end
 end
 or fallback -- default to fast property reads through table
 local newindex = setters and
 function(self, key, value)
 -- write to setter, else to proxy
 local func = setters[key]
 if func then func(self, value)
 else rawset(self, key, value) end
 end
 or fallback -- default to fast property writes through table
 local proxy_mt = { -- create metatable for proxy object
 __newindex = newindex,
 __index = index,
 priv = priv
 }
 local self = setmetatable({}, proxy_mt) -- create proxy object
 return self
end

Here's some tests of that

-- Test Suite
-- test: typical usage
local Apple = {}
Apple.__index = Apple
function Apple:drop()
 return self.color .. " apple dropped"
end
local Apple_attribute_setters = {
 color = function(self, color)
 local priv = getmetatable(self).priv
 assert(color == "red" or color == "green")
 priv.color = string.upper(color)
 end
}
function Apple:new()
 local priv = {color = "RED"} -- private attributes in instance
 local self = make_proxy(Apple, priv, nil, Apple_attribute_setters, true)
 return self
end
local a = Apple:new()
assert("RED" == a.color)
a:drop() -- "RED apple dropped"
a.color = "green"
assert("GREEN apple dropped" == a:drop())
a.color = "red"
assert("RED apple dropped" == a:drop())
a.weight = 123 -- new field
assert(123 == a.weight)
-- fails as expected (invalid color)
local is_ok = pcall(function() a.color = "blue" end)
assert(not is_ok)
-- test: simple
local T = {}
T.__index = T
local T_setters = {
 a = function(self, value)
 local priv = getmetatable(self).priv
 priv.a = value * 2
 end
}
local T_getters = {
 b = function(self, value)
 local priv = getmetatable(self).priv
 return priv.a + 1
 end
}
function T:hello()
 return 123
end
function T:new() return make_proxy(T, {a=5}, T_getters, T_setters) end
local t = T:new()
assert(123 == t:hello())
assert(nil == t.hello2)
assert(nil == t.a)
assert(6 == t.b)
t.a = 10
assert(nil == t.a)
assert(21 == t.b)
-- test: is_expose_private = true
local t = make_proxy(T, {a=5}, T_getters, T_setters, true)
assert(5 == t.a)
assert(6 == t.b)
print("done")

Variations of this are possible, and this might not be optimal (--RiciLake). You may have different design constraints. One suggestion was possibly to memoize the lookup Apple_attribute_funcs[key] or abstract away the actual rawset out of the setter functions.

-- DavidManura

Here is another way of doing this, shown first in lua, then again in C:

-- Rewrite in lua of array example from http://www.lua.org/pil/28.4.html
-- that implements both array and OO access.
array = {
 new = function(self, size)
 local o = {
 _size = size,
 _array = {},
 }
 for i = 1, o._size do
 o._array[i] = 0
 end
 setmetatable(o, self)
 return o
 end,
 size = function(self)
 return self._size
 end,
 get = function(self, i)
 -- should do bounds checking on array
 return self._array[tonumber(i)]
 end,
 set = function(self, i, v)
 -- should do bounds checking on array
 self._array[tonumber(i)] = tonumber(v)
 end,
 __index = function(self, key)
 return getmetatable(self)[key] or self:get(key)
 end,
 __newindex = function(self, i, v)
 self:set(i, v)
 end,
}

In C, this is:

/*
Rewrite in C of array example from http://www.lua.org/pil/28.4.html that
implements both array and OO access.
Lacks bounds checking, its not pertinent to this example.
*/
#include "lauxlib.h"
#include "lua.h"
#include <assert.h>
#include <stdint.h>
#include <string.h>
#define ARRAY_REGID "22d3fa81-aef3-4335-be43-6ff037daf78e"
#define ARRAY_CLASS "array"
struct array {
	lua_Integer size;
	lua_Number data[1];
};
typedef struct array* array;
static array array_check(lua_State* L, int index) 
{
	void* userdata = luaL_checkudata(L,index,ARRAY_REGID);
	assert(userdata);
	return userdata;
}
int array_new(lua_State* L) 
{
	// Ignoring [1], the "array" global table.
	int size = luaL_checkinteger(L, 2);
	array self = (array) lua_newuserdata(L,sizeof(*self) + (size-1) * sizeof(self->data));
	self->size = size;
	for(size = 0; size < self->size; size++)
		self->data[size] = 0;
	luaL_getmetatable(L, ARRAY_REGID);
	lua_setmetatable(L, -2);
	return 1;
}
int array_size(lua_State* L) 
{
	array self = array_check(L, 1);
	lua_pushinteger(L, self->size);
	return 1;
}
int array_get(lua_State* L) 
{
	array self = array_check(L, 1);
	lua_Integer i = luaL_checkinteger(L, 2);
	// TODO bounds checking on i
	lua_pushnumber(L, self->data[i-1]);
	return 1;
}
int array_set(lua_State* L) 
{
	array self = array_check(L, 1);
	lua_Integer i = luaL_checkinteger(L, 2);
	lua_Number v = luaL_checknumber(L, 3);
	// TODO bounds checking on i
	self->data[i-1] = v;
	return 0;
}
int array_index(lua_State* L) 
{
	const char* key = luaL_checkstring(L, 2);
	lua_getmetatable(L, 1);
	lua_getfield(L, -1, key);
 	// Either key is name of a method in the metatable
	if(!lua_isnil(L, -1))
		return 1;
	// ... or its a field access, so recall as self.get(self, value).
	lua_settop(L, 2);
	return array_get(L);
}
static const struct luaL_reg array_class_methods[] = {
	{ "new", array_new },
	{ NULL, NULL }
};
static const struct luaL_reg array_instance_methods[] = {
	{ "get", array_get },
	{ "set", array_set },
	{ "size", array_size },
	{ "__index", array_index },
	{ "__newindex", array_set },
	{ NULL, NULL }
};
int array_open(lua_State* L) 
{
	luaL_newmetatable(L, ARRAY_REGID);
	luaL_openlib(L, NULL, array_instance_methods, 0);
	luaL_openlib(L, ARRAY_CLASS, array_class_methods, 0);
	return 1;
}

For both implementations, array can be used as:

o = array:new(3)
print(o:size())
o[1] = 1
o[2] = 2
o[3] = 3
print(o:get(2))
o:set(3, -1)
print(o[3])

-- see also GeneralizedPairsAndIpairs to allow "pairs" and "ipairs" to work with this.

Object Properties

See Also