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).

 

[Eikonium]

Update to 1.1b:

• Fixed a bug with the integer-based state iteration, where using the break-keyword to exit a pairs-loop early would cause an integer leak (not really a bug, but still annoying). The code is now using table-based state iteration involving table recycling instead, which leaves a table for garbage collection every time the break-keyword is used. Thanks @moddiemads for reporting the leak and @maddeem for bringing table-recycling to my attention.

I unfortunately wasn't able to get rid of both garbage collection and memory leaks under all circumstances. The current code still causes one table to be garbage collected every time the break-keyword is used, which I prefer over the integer leak it was producing previously. Loops not using break are not affected by the change and will neither cause leaks nor gabarge collection both before and after the update.

As a side note, I could have solved this without garbage collection after break in Lua 5.4 using the __close-metamethod, but Wc3 is using Lua 5.3

 

[moddiemads]

A very elegant solution to the problem, implemented with simplicity and precision.

 

[Wrda]

As always, Eikonium is a beast at this.