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