Multiple Indices

wiki

-- Creates a special table that accepts keys that are arrays..

-- You must specified the expected length of this array when

-- creating a MultiTable.

--

-- Given mt = MultiTable(3), accessing mt[{1,2,3}] semantically

-- acts like mt[1][2][3].

--

-- You can also access using a function call syntax.  The following

-- are equivalent:

--    mt[{1,2,3}], mt(1,2,3), mt{1,2,3}

--

function MultiDimTable( dimension )

    if not dimension then

        error( "MultiDimTable expected dimension, got nil" )

    end



    local mt = {}    -- all the nested access is hidden here



    local function mt_index(t, k)

        if type(k) ~= 'table' then

            return t[{k}]

        end

        if dimension ~= #k then

            error("MultiTable key dimension was " .. #k .. ",

                  expected " .. dimension)

        end

        local v = mt

        for i = 1, #k do

            v = v[ k[i] ]

            if not v then return nil end

        end

        return v

    end



    local function mt_newindex(t, k, v)

        if type(k) ~= 'table' then

            t[{k}] = v

            return

        end

        if dimension ~= #k then

            error("MultiTable key dimension was " .. #k .. ",

                  expected " .. dimension)

        end

        local n = mt

        for i = 1, #k - 1 do

            local n_old, k_i = n, k[i]

            n = n[k_i]

            if not n then n = {} ; n_old[k_i] = n end

        end

        n[k[#k]] = v

    end



    local function mt_call(t, k, ...)

        if type(k) == 'table' then

            return t[k]

        end

        return t[{k, ...}]

    end



    return setmetatable( {}, {

        __index = mt_index, __newindex = mt_newindex, __call = mt_call } )

end





-- tests

do

    local res, err

    res, err = pcall( function() MultiDimTable() end )

    local mt1 = MultiDimTable(1)

    mt1[4] = 5

    assert( mt1[{4}] == 5 )

    assert( mt1[4]   == 5 )

    assert( mt1{4}   == 5 )

    assert( mt1(4)   == 5 )



    mt1['abc'] = '123'

    assert( mt1[{'abc'}] == '123' )

    assert( mt1['abc'] == '123' )

    assert( mt1({'abc'}) == '123' )

    assert( mt1('abc') == '123' )



    res, err = pcall( function() return mt1[{1,2}] end )

    assert( not res and string.match(err,

        'MultiTable key dimension was 2, expected 1') )



    res, err = pcall( function() mt1[{1,2}] = 4 end )

    assert( not res and string.match(err,

        'MultiTable key dimension was 2, expected 1') )



    for i = 1, 100 do

        local n = {}

        for j = 1, i do table.insert(n, math.random()) end

        local val = math.random()

        local mtn = MultiDimTable(i)

        mtn[n] = val

        assert( mtn[n]           == val )

        assert( mtn(n)           == val )

        assert( mtn{unpack(n)}   == val )

        assert( mtn[{unpack(n)}] == val )

    end

end

Original Page Contents

do             

    local meta = {}



    local xlate = {[0] = "x", "y", "z"}



    function meta:__index(key)

        if xlate[key] then return rawget(self, xlate[key]) end

    end



    function meta:__newindex(key, val)



      if xlate[key] then

        rawset(self, xlate[key], val)

      else

        rawset(self, key, val)

      end

    end

  

    function Vector(x, y, z)

      return setmetatable({x=x, y=y, z=z}, meta)

    end

end



a = Vector(1, 2, 3)



=a.x

1

 =a[0]

1

 a[2] = 7

 =a.z

7

How does this work?

Firstly data is ONLY stored in x,y,z values in out table created via Vector(1, 2, 3). We use a dummy table and a lookup table to achieve our goal.

TBC....