The problem
Using my Factorio reflection library
discussed previously involves interacting with Lua
values that are a combination of the actual value and some metadata,
so you have to know about those values to use them. Worse, the
interactions I defined are quite verbose. The main thing you're like to
want to do on a value is lookup a property on it. Normally in Lua that
looks like
but if instead of table
you have a wrapped
value from the reflection
library, you would look up key
on it with
ReflectionLibraryMod.typed_object_lookup_property(
wrapped, key).value
If you want to do multiple levels of property lookups, then this quickly
gets quite unwieldy.
The solution
Lua supports operator overloading through a
mechanism it calls metatables (some additional
examples).
Using that mechanism, the library defines a value
ReflectionLibraryMod.typed_data_raw
that can be indexed as
wrapped[key]
and assigned to like wrapped[key] = newValue
.
The basic setup looks like
local prototype = {} -- table for methods
local mt = {}
mt.__index = function (table, key)
local res = prototype[key]
or ReflectionLibraryMod.wrap_typed_object(
ReflectionLibraryMod.typed_object_lookup_property(
table._private, key))
if res == nil then
if key == "_value" then
res = table._private.value
end
end
return res
end
mt.__newindex = function (table, key, newValue)
-- If newValue is a wrapped typed value, then unwrap it.
if getmetatable(newValue) == mt then
newValue = newValue._private.value
end
table._private.value[key] = newValue
end
function ReflectionLibraryMod.wrap_typed_object(typedValue)
if typedValue == nil then
return nil
end
local res = {_private = typedValue}
setmetatable(res, mt)
return res
end
Any additional properties would be defined next to the definition of
_value
. And any methods would be defined on prototype
.
The details