SyncedTable

[Eikonium]

This resource has been moved here from the old Code forum. You can find the old discussion in this thread.

 

[Wrda]

I believe there could be a small improvement on the pairs metamethod:

--Define, how the pairs iteration works
metatable.__pairs = function(t)
    local i = 0
    local latestKey
    return function()
        if latestKey == orderedKeys[i] then
            i = i+1 --only increase i, when the last iterated key is still part of the table. Otherwise use the same i again. This allows the removal of (key,value)-pairs inside the pairs()-iteration.
        end
        latestKey = orderedKeys[i]
        return orderedKeys[i], data[orderedKeys[i]]
    end, t, nil
end

By taking a derived form of maddeem's advice. Since it gets rid of the creation of anonymous function per loop. NewTable and ReleaseTable belongs to a table recycler script he uses. Perhaps that could be integrated too.

If you ever decide to recycle tables here is a stateless elements function that doesn't create a function per loop:

    local function setIterator(state)
        local i = state.i
        if state.lastKey == state.orderedKeys[i] then
            i = i + 1
            state.i = i
        end
        state.lastKey = state.orderedKeys[i]
        if not state.lastKey then
            state.orderedKeys = nil
            state.i = nil
            ReleaseTable(state)
        end
        return state.lastKey
    end

    function Set:elements()
        local state = NewTable()
        state.i = 0
        state.orderedKeys = self.orderedKeys
        return setIterator, state
    end

Creating such objects are only a problem when there's a lot of demand going on, and the garbage collector probably can't keep up, so this isn't a big deal in most cases.
Nonetheless, this resource is beautiful, and extremely useful for all Lua users, avoiding a lot of headaches.

Approved

 

[Eikonium]

I believe there could be a small improvement on the pairs metamethod:

That's true. Although creating an iterator function per loop is standard in Lua, object creation should be spared where not necessary, especially in Wc3. I think I'd go for an approach that doesn't ever create tables or functions, but just writes necessary loop-data into a pre-existing array. This would even spare table recycling and should be the most efficient way.

Untested example code:

--Idea: allocate one unique loopId to each started SyncedTable-loop. Use that id to save / retreive all necessary data in each step of every loop.
local loopCounters, loopKeys = {}, {}
local loopId = 0 --unique to each loop

local function iterator(state)
    if loopKeys[state] == orderedKeys[loopCounters[state]] then
        loopCounters[state] = loopCounters[state] + 1 --only increase i, when the last iterated key is still part of the table. Otherwise use the same i again. This allows the removal of (key,value)-pairs inside the pairs()-iteration.
    end
    local i = loopCounters[state]
    loopKeys[state] = orderedKeys[i]
    return orderedKeys[i], data[orderedKeys[i]]
end

metatable.__pairs = function(t)
    while loopKeys[loopId] do --loopKeys[loopId] will be nil for finished loops. we could theoretically spare this check, because loopId would realistically never reach an existing loop anyway.
        loopId = loopId + 1
    end
    local state = loopId
    loopCounters[state] = 0
    return iterator, state, nil
end

I will probably find time to incorporate this next weekend.

Nonetheless, this resource is beautiful, and extremely useful for all Lua users, avoiding a lot of headaches.

 

[Eikonium]

Update to version 1.1

• No longer creates an iterator function upon every pairs()-loop, but instead creates a fixed iterator upon SyncedTable creation that uses global indexing to distinguish different loops running at the same time. This puts less pressure on the garbage collector.

Thanks to @maddeem and @Wrda for suggesting improvements on garbage collection workload.

I also improved the resource description. It will hopefully provide a more intuitive explanation to new Lua-mappers as compared to before.

 

[Eikonium]

Hotfix 1.1a:

• Fixed a bug introduced with version 1.1, where using false as a key in a SyncedTable would break a loop early, if another loop was nested upon iterating this exact key (very rare but possible).

(In other words, I did while x do, while I should have done while x ~= nil do, which makes a difference for x = false).