From 7374ab9e96c9fe27b75005c00baf8f9cdd6d40cf Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Tue, 3 Aug 2021 17:30:42 +0200
Subject: [PATCH 01/11] wip

---
 LibEventSourcing.xml  |  1 +
 source/SortedList.lua | 30 ++++++++++++++++++++++++++++++
 source/Util.lua       | 17 +++++++++++++++++
 tests/UtilTest.lua    | 26 ++++++++++++++++++++++++++
 4 files changed, 74 insertions(+)

diff --git a/LibEventSourcing.xml b/LibEventSourcing.xml
index 112aa9f..23ad292 100644
--- a/LibEventSourcing.xml
+++ b/LibEventSourcing.xml
@@ -4,6 +4,7 @@
     <Script file="libs\LibLogger\LibLogger.lua"/>
     <Script file="source\Util.lua"/>
     <Script file="source\SortedList.lua"/>
+    <Script file="source\Table.lua"/>
     <Script file="source\LogEntry.lua"/>
     <Script file="source\IgnoreEntry.lua"/>
     <Script file="source\StateManager.lua"/>
diff --git a/source/SortedList.lua b/source/SortedList.lua
index dcb8504..36464f5 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -40,6 +40,10 @@ end
 function SortedList:state()
     return self._state
 end
+
+--[[
+   Inserts an element into the list, returns the position of the inserted element
+]]
 function SortedList:insert(element)
     if (self._unique) then
         error("This list only supports uniqueInsert")
@@ -54,8 +58,10 @@ function SortedList:insert(element)
     local position = Util.BinarySearch(self._entries, element, self._compare)
     if position == nil then
         table.insert(self._entries, element)
+        return #self._entries
     else
         table.insert(self._entries, position, element)
+        return position
     end
 end
 
@@ -109,3 +115,27 @@ end
 function SortedList:searchGreaterThanOrEqual(entry)
     return Util.BinarySearch(self._entries, entry, self._compare)
 end
+
+--[[
+    Remove an element from the list
+]]
+function SortedList:remove(entry)
+    local position = self:searchGreaterThanOrEqual(entry)
+    Util.DumpTable(entry)
+    print(position)
+    if position == nil or entry == self._entries[position] then
+        error("Element to remove not found")
+    end
+    self._entries[position] = nil
+    return position
+end
+
+--[[
+    Update an element in the list, the assumption here is that the table contents have changed and thus
+    the result of the compare function might have changed too.
+]]
+function SortedList:update(entry)
+    local oldPosition = self:remove(entry)
+    local newPosition = self:insert(entry)
+    return oldPosition, newPosition
+end
\ No newline at end of file
diff --git a/source/Util.lua b/source/Util.lua
index 24131e4..0304346 100644
--- a/source/Util.lua
+++ b/source/Util.lua
@@ -21,6 +21,23 @@ function Util.BinarySearch(list, value, comparator, min, max)
 
     local result = comparator(list[test], value)
 
+    if result == 0 then
+        if (list[test] == value) then
+            return test
+        end
+        -- Linear search left side
+        local linearTest = test
+        while linearTest > 1 and result == 0 do
+            linearTest = linearTest - 1
+            result = comparator(list[linearTest], value)
+            if list[linearTest] == value then
+                return linearTest
+            end
+        end
+
+  
+    end
+
 
 
     if result == -1 then
diff --git a/tests/UtilTest.lua b/tests/UtilTest.lua
index d3348d6..a7391a5 100644
--- a/tests/UtilTest.lua
+++ b/tests/UtilTest.lua
@@ -37,5 +37,31 @@ local function TestBinarySearch()
 
 end
 
+local function TestBinarySearchDuplicates()
+    local comparator = function(a, b)
+        if a.val < b.val then
+            return -1
+        elseif a.val > b.val then
+            return 1
+        else
+            return 0
+        end
+    end
+    local search = { val = 2 }
+    local cases = {
+        { list = {{ val = 1 }, { val = 2 }, search, { val = 2 }}, search = search, expected =  3 },
+        { list = {{ val = 1 }, { val = 1 }, { val = 1 }, { val = 2, a = 4 }, { val = 2, b = 6 }, search}, search = search, expected =  6 },
+        { list = {{ val = 1 }, search, { val = 2 }, { val = 2 }}, search = search, expected =  2 },
+        { list = {{ val = 1 }, search, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }}, search = search, expected =  2 }
+    }
+
+    for _, v in ipairs(cases) do
+        local result = Util.BinarySearch(v.list, v.search, comparator)
+        assertSame(v.expected, result)
+    end
+
+end
+
 TestBinarySearch()
+TestBinarySearchDuplicates()
 printResultsAndExit()

From 8a756f52b42da1a58cfcc78c3519280e2ef9eaa3 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Wed, 4 Aug 2021 11:05:51 +0200
Subject: [PATCH 02/11] feat: add docs implement pause, resume and smarter
 triggers

---
 source/SortedList.lua |  20 ++----
 source/Table.lua      | 145 ++++++++++++++++++++++++++++++++++++++++++
 source/Util.lua       |  10 ++-
 source/docs/Table.md  | 111 ++++++++++++++++++++++++++++++++
 tests/TableTest.lua   |  68 ++++++++++++++++++++
 tests/UtilTest.lua    |   3 +-
 6 files changed, 339 insertions(+), 18 deletions(-)
 create mode 100644 source/Table.lua
 create mode 100644 source/docs/Table.md
 create mode 100644 tests/TableTest.lua

diff --git a/source/SortedList.lua b/source/SortedList.lua
index 36464f5..5cb3171 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -51,8 +51,8 @@ function SortedList:insert(element)
     self._state = self._state + 1
     -- since we expect elements to be mostly appended, we do a shortcut check.
     if (#self._entries == 0 or self._compare(self._entries[#self._entries], element) == -1) then
-        table.insert(self._entries, element)
-        return
+        self._entries[#self._entries + 1] = element
+        return #self._entries
     end
 
     local position = Util.BinarySearch(self._entries, element, self._compare)
@@ -121,21 +121,9 @@ end
 ]]
 function SortedList:remove(entry)
     local position = self:searchGreaterThanOrEqual(entry)
-    Util.DumpTable(entry)
-    print(position)
-    if position == nil or entry == self._entries[position] then
+    if position == nil or entry ~= self._entries[position] then
         error("Element to remove not found")
     end
-    self._entries[position] = nil
+    table.remove(self._entries, position)
     return position
-end
-
---[[
-    Update an element in the list, the assumption here is that the table contents have changed and thus
-    the result of the compare function might have changed too.
-]]
-function SortedList:update(entry)
-    local oldPosition = self:remove(entry)
-    local newPosition = self:insert(entry)
-    return oldPosition, newPosition
 end
\ No newline at end of file
diff --git a/source/Table.lua b/source/Table.lua
new file mode 100644
index 0000000..cf0bb8c
--- /dev/null
+++ b/source/Table.lua
@@ -0,0 +1,145 @@
+local Table, _ = LibStub:NewLibrary("EventSourcing/Table", 1)
+if not Table then
+    return
+end
+
+local Util = LibStub("EventSourcing/Util")
+local SortedList = LibStub("EventSourcing/SortedList")
+
+
+local function curryOne(func, param)
+    return function(...)
+        return func(param, ...)
+    end
+end
+
+
+local function addRow(table, row)
+    -- Add the row to each index
+    local triggers = {}
+    for indexName, index in pairs(table.indices) do
+        local position = index:insert(row)
+        -- Check watches
+        for _, watch in ipairs(table.watches[indexName]) do
+            local callback, offset, length = unpack(watch)
+            if position >= offset and position <= offset + length then
+                triggers[#triggers + 1] = callback
+            end
+        end
+    end
+
+    -- Execute triggers
+    for _, callback in ipairs(triggers) do
+        pcall(callback, 'addRow')
+    end
+end
+
+local function updateRow(table, row, mutator)
+    -- Get the current location in each index
+    local oldPositions = {}
+    for indexName, index in pairs(table.indices) do
+        oldPositions[indexName] = index:remove(row)
+    end
+    mutator()
+
+    -- After mutating we insert the row into all indices again
+    local triggers = {}
+    for indexName, index in pairs(table.indices) do
+        local newPosition = index:insert(row)
+        -- Check watches
+        for _, watch in ipairs(table.watches[indexName]) do
+            local callback, offset, length = unpack(watch)
+            if oldPositions[indexName] ~= newPosition and (
+                (oldPositions[indexName] >= offset and oldPositions[indexName] <= offset + length)
+                or  (newPosition >= offset and newPosition <= offset + length)
+            ) then
+                triggers[#triggers + 1] = callback
+            end
+        end
+    end
+
+    -- Execute triggers
+    for _, callback in ipairs(triggers) do
+        pcall(callback, 'updateRow')
+    end
+end
+
+local function iterateByIndex(table, name, start, length)
+    local i = (start or 1) - 1
+    local data = table.indices[name]:entries()
+    local n = math.min(#data, i + (length or 0))
+    return function()
+        i = i + 1
+        if i <=n then return i, data[i] end
+    end
+end
+
+--[[
+    Register a callback to be called when a specific part of the index changes
+    Returns a function that can be used to remove the watch and a function to update the offset / length.
+]]
+local function watchIndexRange(table, indexName, callback, offset, length)
+    local watches = table.watches[indexName]
+    local watch = {0, offset, length}
+    local paused = false
+    -- We want to pass an iterator to the callback, so we curry it.
+    watch[1] = function(reason)
+        return paused or callback(iterateByIndex(table, indexName, watch[2], watch[3]), reason)
+    end
+    watches[#watches+1] = watch
+
+    local updateOffset = function(newOffset)
+        watch[2] = newOffset
+        watch[1]('updateOffset')
+    end
+
+    local update = function(newOffset, newLength)
+        watch[2] = newOffset
+        watch[3] = newLength
+        watch[1]('updateWatch')
+    end
+
+    local cancel = function()
+        for i, v in ipairs(watches) do
+            if v == watch then
+                watches[i] = nil
+                break;
+            end
+        end
+    end
+
+    return {
+        update = update,
+        updateOffset = updateOffset,
+        cancel = cancel,
+        pause = function() paused = true end,
+        resume = function() paused = false end,
+        trigger = function() watch[1]('trigger') end
+    }
+end
+
+
+Table.new = function(indices)
+    local private = {
+        -- A list of index data tables
+        indices = {},
+        watches = {},
+    }
+
+    for name, compare in pairs(indices) do
+        Util.assertFunction(compare)
+        private.indices[name] = SortedList:new({}, compare, false)
+        private.watches[name] = {}
+    end
+    local public = {
+        addRow = curryOne(addRow, private),
+        updateRow = curryOne(updateRow, private),
+        iterateByIndex = curryOne(iterateByIndex, private),
+        watchIndexRange = curryOne(watchIndexRange, private)
+    }
+
+    return public
+end
+
+
+
diff --git a/source/Util.lua b/source/Util.lua
index 0304346..6a8d2c3 100644
--- a/source/Util.lua
+++ b/source/Util.lua
@@ -35,7 +35,15 @@ function Util.BinarySearch(list, value, comparator, min, max)
             end
         end
 
-  
+        linearTest = test
+        result = 0
+        while linearTest <= #list and result == 0 do
+            linearTest = linearTest + 1
+            result = comparator(list[linearTest], value)
+            if list[linearTest] == value then
+                return linearTest
+            end
+        end
     end
 
 
diff --git a/source/docs/Table.md b/source/docs/Table.md
new file mode 100644
index 0000000..f1bd763
--- /dev/null
+++ b/source/docs/Table.md
@@ -0,0 +1,111 @@
+# Table library
+
+The table library allows you to manage a collection of rows (represented as tables).
+The table supports multiple indices as well as change events for specific parts of an index.
+
+When inserting rows into the table you should make sure that the rows are not edited externally.
+
+## Index
+An index is defined by a comparison function, the comparison can be single or multiple columns.
+See `Util.CreateMultiFieldSorter` and `Util.CreateFieldSorter`.
+
+```lua
+local table = Table.new({
+    primary = Util.createFieldSorter('a')
+})
+
+
+table.addRow({a = 5})
+table.addRow({a = 3})
+
+for i, v in ipairs(table.iterateByIndex('primary') do
+  print(i, v.a)
+done
+```
+Will output
+```
+1    3
+2    5
+```
+
+Note the use of `iterateByIndex` this creates an iterator allowing you to go over the elements in any order as long as there is an index for it. The iteration itself is really cheap since the index is already in memory.
+
+
+## Updating rows
+To update a row you should wrap the code in a closure and pass it to the table:
+```lua
+local table = Table.new({
+    primary = Util.createFieldSorter('a')
+})
+
+local row = {a = 5, t = 'row1'}
+table.addRow(row)
+table.addRow({a = 3, t = 'row2'})
+
+for i, v in ipairs(table.iterateByIndex('primary') do
+  print(i, v.a, v.t)
+done
+
+table.updateRow(row, function()
+    row.a = 1
+))
+
+for i, v in ipairs(table.iterateByIndex('primary') do
+  print(i, v.a, v.t)
+done
+
+```
+Will output
+```
+1    3    row2
+2    5    row1
+1    1    row1
+2    3    row2
+```
+
+Internally the library will do some bookkeeping to make sure indices remain sorted.
+
+## Watching index ranges
+Imagine you have a very large table, 10.000 records for example.
+When displaying this table in a UI, most records won't be visible. Suppose there are 50 visible lines, each line showing data from 1 row.
+
+Now if any of the rows change, normally what you do is redraw the whole table, regardless if the change is relevant.
+
+To aid with the library supports watching indexes for changes. The reasoning is that you will watch the index that has the same sort order used in your UI.
+
+```lua
+local table = Table.new({
+    name = Util.createFieldSorter('name'),
+    age = Util.createFieldSorter('age')
+})
+
+-- build the initial table.
+table.addRow({name = "Bob1", age = 20})
+table.addRow({name = "Bob2", age = 30})
+table.addRow({name = "Bob3", age = 40})
+table.addRow({name = "Bob4", age = 25})
+table.addRow({name = "Bob5", age = 35})
+table.addRow({name = "Bob6", age = 45})
+local UI = ImaginaryScrollTable()
+-- Let's assume our UI is very small, so it can only show 2 rows.
+-- We pass an offset, 1 (our UI scrollbar is at the top) and a length.
+local watch = table.watchIndexRange('age', function(iterator, reason) 
+    -- This function is called every time something in our visible area has changed.
+    -- Reason contains the cause (addRow, updateRow, trigger, updateWatch, updateOffset)
+
+end, 1, 2)
+
+-- The watch object allows us to cancel our subscription as well as update our offset & length.
+
+UI.onScroll = function(offset) {
+    -- Updating the offset or length will always trigger the watch.
+    watch.updateOffset(offset)
+}
+
+-- Initial setup of UI is done, load data.
+watch.trigger()
+
+-- When the UI closes you can cancel the watch.
+watch.cancel()
+```
+
diff --git a/tests/TableTest.lua b/tests/TableTest.lua
new file mode 100644
index 0000000..68df620
--- /dev/null
+++ b/tests/TableTest.lua
@@ -0,0 +1,68 @@
+beginTests()
+
+local Util = LibStub("EventSourcing/Util")
+local Table = LibStub("EventSourcing/Table")
+
+
+local table = Table.new({
+    a = Util.CreateMultiFieldSorter('a'),
+    inverse_a = Util.InvertSorter(Util.CreateMultiFieldSorter('a'))
+
+})
+
+table.addRow({
+    a =  5
+})
+
+table.addRow({
+    a =  10
+})
+
+table.addRow({
+    a =  11
+})
+
+table.addRow({
+    a =  8
+})
+table.addRow({
+    a =  8
+})
+table.addRow({
+    a =  8
+})
+table.addRow({
+    a =  8
+})
+
+local someRow = {
+    a =  8
+}
+
+table.addRow(someRow)
+
+local updateCounter = 0
+local watch = table.watchIndexRange('a', function(iterator, reason) 
+    updateCounter = updateCounter + 1
+end, 1, 5)
+
+assertSame(0, updateCounter)
+table.addRow({
+    a =  1
+})
+
+assertSame(1, updateCounter)
+watch.update(1, 50)
+assertSame(2, updateCounter)
+
+table.updateRow(someRow, function() 
+    someRow.a = 400
+end)
+assertSame(3, updateCounter)
+table.updateRow(someRow, function() 
+    someRow.a = 400
+end)
+assertSame(3, updateCounter)
+
+
+printResultsAndExit()
diff --git a/tests/UtilTest.lua b/tests/UtilTest.lua
index a7391a5..cf4f564 100644
--- a/tests/UtilTest.lua
+++ b/tests/UtilTest.lua
@@ -52,7 +52,8 @@ local function TestBinarySearchDuplicates()
         { list = {{ val = 1 }, { val = 2 }, search, { val = 2 }}, search = search, expected =  3 },
         { list = {{ val = 1 }, { val = 1 }, { val = 1 }, { val = 2, a = 4 }, { val = 2, b = 6 }, search}, search = search, expected =  6 },
         { list = {{ val = 1 }, search, { val = 2 }, { val = 2 }}, search = search, expected =  2 },
-        { list = {{ val = 1 }, search, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }}, search = search, expected =  2 }
+        { list = {{ val = 1 }, search, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }}, search = search, expected =  2 },
+        { list = {{ val = 1 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, { val = 2 }, search}, search = search, expected =  8 }
     }
 
     for _, v in ipairs(cases) do

From d871089f35f85216320f946ed6cea000f4f94847 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Wed, 4 Aug 2021 11:32:27 +0200
Subject: [PATCH 03/11] fix: array out of bounds in linear search part of
 binary search

---
 source/SortedList.lua |  7 +++----
 source/Table.lua      |  6 +++++-
 source/Util.lua       |  7 ++-----
 tests/TableTest.lua   | 11 +++++++++--
 4 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/source/SortedList.lua b/source/SortedList.lua
index 5cb3171..17c5df4 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -56,13 +56,12 @@ function SortedList:insert(element)
     end
 
     local position = Util.BinarySearch(self._entries, element, self._compare)
-    if position == nil then
-        table.insert(self._entries, element)
-        return #self._entries
-    else
+    if position ~= nil then
         table.insert(self._entries, position, element)
         return position
     end
+    table.insert(self._entries, element)
+    return #self._entries
 end
 
 --[[
diff --git a/source/Table.lua b/source/Table.lua
index cf0bb8c..7ca956f 100644
--- a/source/Table.lua
+++ b/source/Table.lua
@@ -113,7 +113,11 @@ local function watchIndexRange(table, indexName, callback, offset, length)
         updateOffset = updateOffset,
         cancel = cancel,
         pause = function() paused = true end,
-        resume = function() paused = false end,
+        resume = function()
+             paused = false
+             watch[1]('resume')
+
+        end,
         trigger = function() watch[1]('trigger') end
     }
 end
diff --git a/source/Util.lua b/source/Util.lua
index 6a8d2c3..5329db8 100644
--- a/source/Util.lua
+++ b/source/Util.lua
@@ -4,10 +4,7 @@ if not Util then
 return end
 -- Searches for the first index that has value >= to the given value
 function Util.BinarySearch(list, value, comparator, min, max)
-    if type(list) ~= 'table' then
-        error("Argument 1 must be a table")
-    end
-
+    Util.assertTable(list, 'list')
     if min == nil then
         min = 1
         max = #list
@@ -37,7 +34,7 @@ function Util.BinarySearch(list, value, comparator, min, max)
 
         linearTest = test
         result = 0
-        while linearTest <= #list and result == 0 do
+        while linearTest < #list and result == 0 do
             linearTest = linearTest + 1
             result = comparator(list[linearTest], value)
             if list[linearTest] == value then
diff --git a/tests/TableTest.lua b/tests/TableTest.lua
index 68df620..b53d471 100644
--- a/tests/TableTest.lua
+++ b/tests/TableTest.lua
@@ -5,8 +5,8 @@ local Table = LibStub("EventSourcing/Table")
 
 
 local table = Table.new({
-    a = Util.CreateMultiFieldSorter('a'),
-    inverse_a = Util.InvertSorter(Util.CreateMultiFieldSorter('a'))
+    a = Util.CreateFieldSorter('a'),
+    inverse_a = Util.InvertSorter(Util.CreateFieldSorter('a'))
 
 })
 
@@ -64,5 +64,12 @@ table.updateRow(someRow, function()
 end)
 assertSame(3, updateCounter)
 
+watch.pause()
+for i = 0, 10000 do
+    table.addRow({a = math.random(10000)})
+end
+
+watch.resume()
+
 
 printResultsAndExit()

From 0d6ecc6dfb92e0092b192ad4641f4e0caaaa3ded Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Mon, 13 Sep 2021 11:49:45 +0200
Subject: [PATCH 04/11] add rowcount to watch callback

---
 source/Table.lua | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/source/Table.lua b/source/Table.lua
index 7ca956f..13bcfcd 100644
--- a/source/Table.lua
+++ b/source/Table.lua
@@ -17,6 +17,7 @@ end
 local function addRow(table, row)
     -- Add the row to each index
     local triggers = {}
+    table.rowCount = table.rowCount + 1
     for indexName, index in pairs(table.indices) do
         local position = index:insert(row)
         -- Check watches
@@ -37,7 +38,7 @@ end
 local function updateRow(table, row, mutator)
     -- Get the current location in each index
     local oldPositions = {}
-    for indexName, index in pairs(table.indices) do
+    for indexName, index in pairs(table.indices) do        
         oldPositions[indexName] = index:remove(row)
     end
     mutator()
@@ -49,7 +50,8 @@ local function updateRow(table, row, mutator)
         -- Check watches
         for _, watch in ipairs(table.watches[indexName]) do
             local callback, offset, length = unpack(watch)
-            if oldPositions[indexName] ~= newPosition and (
+            -- trigger for same spot
+            if (true or oldPositions[indexName] ~= newPosition) and (
                 (oldPositions[indexName] >= offset and oldPositions[indexName] <= offset + length)
                 or  (newPosition >= offset and newPosition <= offset + length)
             ) then
@@ -84,7 +86,7 @@ local function watchIndexRange(table, indexName, callback, offset, length)
     local paused = false
     -- We want to pass an iterator to the callback, so we curry it.
     watch[1] = function(reason)
-        return paused or callback(iterateByIndex(table, indexName, watch[2], watch[3]), reason)
+        return paused or callback(iterateByIndex(table, indexName, watch[2], watch[3]), reason, table.rowCount)
     end
     watches[#watches+1] = watch
 
@@ -128,6 +130,7 @@ Table.new = function(indices)
         -- A list of index data tables
         indices = {},
         watches = {},
+        rowCount = 0
     }
 
     for name, compare in pairs(indices) do

From 67913ed4571b9c35c4feaa79fe89b2a6fd28d873 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Sat, 25 Sep 2021 22:46:20 +0200
Subject: [PATCH 05/11] fix: warning for slow event handlers

---
 source/StateManager.lua | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/source/StateManager.lua b/source/StateManager.lua
index 3ecdc25..abe8f26 100644
--- a/source/StateManager.lua
+++ b/source/StateManager.lua
@@ -27,6 +27,7 @@ local function hydrateEntryFromList(entry, data)
 end
 
 local function trigger(stateManager, event, ...)
+    local start = GetTimePreciseSec()
     for _, callback in ipairs(stateManager.listeners[event] or {}) do
         -- trigger callback, pass state manager
         local success, result = pcall(callback, stateManager, ...)
@@ -35,6 +36,10 @@ local function trigger(stateManager, event, ...)
         end
 
     end
+    local duration = GetTimePreciseSec() - start
+    if (duration > 0.01) then
+        stateManager.logger:Warning("Event handlers for %s took %f seconds, keep your event handlers below 10ms", event, duration)
+    end
 end
 
 local function entryToList(entry)

From b22e8aeb8718cd3c888caff33deda40aa2f6ad27 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Sat, 25 Sep 2021 22:47:45 +0200
Subject: [PATCH 06/11] fix: CS

---
 source/Table.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/Table.lua b/source/Table.lua
index 13bcfcd..c55f52b 100644
--- a/source/Table.lua
+++ b/source/Table.lua
@@ -38,7 +38,7 @@ end
 local function updateRow(table, row, mutator)
     -- Get the current location in each index
     local oldPositions = {}
-    for indexName, index in pairs(table.indices) do        
+    for indexName, index in pairs(table.indices) do
         oldPositions[indexName] = index:remove(row)
     end
     mutator()

From 20f0a22d2d9afcb3d1f230f58165a748f7a64be6 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Sat, 25 Sep 2021 22:49:44 +0200
Subject: [PATCH 07/11] fix: minor performance improvement

---
 source/SortedList.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/SortedList.lua b/source/SortedList.lua
index 17c5df4..6ac02dd 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -60,7 +60,7 @@ function SortedList:insert(element)
         table.insert(self._entries, position, element)
         return position
     end
-    table.insert(self._entries, element)
+    self._entries[#self._entries + 1] = element
     return #self._entries
 end
 

From 3ffa5090ce21524e6cfca0474b2e1e5483e9a0b8 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Sat, 25 Sep 2021 22:52:05 +0200
Subject: [PATCH 08/11] fix: tests

---
 tests/TableTest.lua | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/TableTest.lua b/tests/TableTest.lua
index b53d471..50cd79b 100644
--- a/tests/TableTest.lua
+++ b/tests/TableTest.lua
@@ -62,14 +62,15 @@ assertSame(3, updateCounter)
 table.updateRow(someRow, function() 
     someRow.a = 400
 end)
-assertSame(3, updateCounter)
+assertSame(4, updateCounter)
 
 watch.pause()
 for i = 0, 10000 do
     table.addRow({a = math.random(10000)})
 end
-
+assertSame(4, updateCounter)
 watch.resume()
+assertSame(5, updateCounter)
 
 
 printResultsAndExit()

From dedb8c7596b57aa3d624c7d4ed6cb57c98c3af60 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Wed, 29 Sep 2021 23:00:08 +0200
Subject: [PATCH 09/11] fix: update minor version number

---
 source/SortedList.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/SortedList.lua b/source/SortedList.lua
index 6ac02dd..eb791d5 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -2,7 +2,7 @@
     Sorted lists with an insert API
 ]]--
 
-local SortedList, _ = LibStub:NewLibrary("EventSourcing/SortedList", 1)
+local SortedList, _ = LibStub:NewLibrary("EventSourcing/SortedList", 2)
 if not SortedList then
     return end
 

From f961fc14de32a6b3724b7cc681df8efe97218016 Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Wed, 29 Sep 2021 23:04:40 +0200
Subject: [PATCH 10/11] fix: minor speed improvement

---
 source/SortedList.lua | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/source/SortedList.lua b/source/SortedList.lua
index eb791d5..11a9e92 100644
--- a/source/SortedList.lua
+++ b/source/SortedList.lua
@@ -73,13 +73,13 @@ end
 function SortedList:uniqueInsert(element)
     self._state = self._state + 1
     if (#self._entries == 0 or self._compare(self._entries[#self._entries], element) == -1) then
-        table.insert(self._entries, element)
+        self._entries[#self._entries + 1] = element
         return true
     end
 
     local position = Util.BinarySearch(self._entries, element, self._compare)
     if position == nil then
-        table.insert(self._entries, element)
+        self._entries[#self._entries + 1] = element
     elseif self._compare(self._entries[position], element) ~= 0 then
         table.insert(self._entries, position, element)
     else
@@ -100,16 +100,6 @@ function SortedList:wipe()
     end
     self._state = self._state + 1
 end
--- We don't return a value since we are change the table, this makes it clear for consuming code
---function SortedList:cast(table, compare)
---    if (table._entries == nil) then
---        error("This is not a sorted list table")
---    end
---    setmetatable(table, SortedList)
---    table._compare = compare
---end
-
-
 
 function SortedList:searchGreaterThanOrEqual(entry)
     return Util.BinarySearch(self._entries, entry, self._compare)

From 52a7cc99916a282592d86b04a5f2d48694ea58dc Mon Sep 17 00:00:00 2001
From: Sam Mousa <sam@mousa.nl>
Date: Sat, 22 Oct 2022 12:34:34 +0200
Subject: [PATCH 11/11] chore: more tests

---
 readme.MD           | 15 ++++++--
 source/Table.lua    | 31 +++++++++++++---
 tests/TableTest.lua | 87 ++++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 122 insertions(+), 11 deletions(-)

diff --git a/readme.MD b/readme.MD
index 1b3bd09..dfe899d 100644
--- a/readme.MD
+++ b/readme.MD
@@ -51,10 +51,10 @@ Then there is the issue of responding to requests on broadcast channels. We don'
 with data...
 
 - When announcing that you are able to send a hash include a timestamp.
-- If multiple announcements are sent simultaneously, only the sender with the lowest timestamp (and player name in case of same timestamp) 
-  will start sending data after at 5 seconds.  
+- If multiple announcements are sent simultaneously, only the sender with the lowest timestamp (and player name in case of same timestamp)
+  will start sending data after at 5 seconds.
+
 
-  
 Denial of service
 -----------------
 The consuming addon is responsible for providing secure communication channels.
@@ -62,6 +62,15 @@ Specifically if we can only authorize entries but not sync messages someone can
 block sync by rebroadcasting every advertisement with a lower timestamp and then never sending actual data.
 
 
+# V2
+
+Work has started on V2 for WOTLK.
+Some improvements are on the list:
+- simplify auth
+- allow zero or more handlers for log entries
+- allow zero or more handlers for reset
+- more efficient serialization
+
 # Contributions
 
 As much as possible is automated when it comes to chores in this library.
diff --git a/source/Table.lua b/source/Table.lua
index c55f52b..0a0c270 100644
--- a/source/Table.lua
+++ b/source/Table.lua
@@ -28,6 +28,9 @@ local function addRow(table, row)
             end
         end
     end
+    for indexName, uniqueIndex in pairs(table.uniqueIndices) do
+        uniqueIndex[indexName] = row
+    end
 
     -- Execute triggers
     for _, callback in ipairs(triggers) do
@@ -76,13 +79,20 @@ local function iterateByIndex(table, name, start, length)
     end
 end
 
+local function retrieveByUniqueIndex(table, indexName, key)
+    return table.uniqueIndices[indexName][key]
+end
+
 --[[
     Register a callback to be called when a specific part of the index changes
     Returns a function that can be used to remove the watch and a function to update the offset / length.
 ]]
 local function watchIndexRange(table, indexName, callback, offset, length)
+    if table.indices[indexName] == nil then
+        error(string.format("Attempt to watch unknown sorted index %s"))
+    end
     local watches = table.watches[indexName]
-    local watch = {0, offset, length}
+    local watch = {nil, offset, length}
     local paused = false
     -- We want to pass an iterator to the callback, so we curry it.
     watch[1] = function(reason)
@@ -125,24 +135,37 @@ local function watchIndexRange(table, indexName, callback, offset, length)
 end
 
 
-Table.new = function(indices)
+-- unique indices are implemented as dictionaries
+Table.new = function(uniqueIndices, indices)
     local private = {
         -- A list of index data tables
         indices = {},
         watches = {},
+        -- store data
+        uniqueIndices = {},
+        -- store retriever function
+        uniqueIndexers = {},
         rowCount = 0
     }
 
-    for name, compare in pairs(indices) do
+    for name, compare in pairs(indices or {}) do
         Util.assertFunction(compare)
         private.indices[name] = SortedList:new({}, compare, false)
         private.watches[name] = {}
     end
+    for name, indexer in pairs(uniqueIndices or {}) do
+        Util.assertFunction(indexer)
+        private.uniqueIndices[name] = {}
+        private.uniqueIndexers[name] = indexer
+        private.watches[name] = {}
+    end
     local public = {
         addRow = curryOne(addRow, private),
         updateRow = curryOne(updateRow, private),
         iterateByIndex = curryOne(iterateByIndex, private),
-        watchIndexRange = curryOne(watchIndexRange, private)
+        watchIndexRange = curryOne(watchIndexRange, private),
+        retrieveByUniqueIndex = curryOne(retrieveByUniqueIndex, private)
+
     }
 
     return public
diff --git a/tests/TableTest.lua b/tests/TableTest.lua
index 50cd79b..190a76b 100644
--- a/tests/TableTest.lua
+++ b/tests/TableTest.lua
@@ -5,6 +5,9 @@ local Table = LibStub("EventSourcing/Table")
 
 
 local table = Table.new({
+
+
+}, {
     a = Util.CreateFieldSorter('a'),
     inverse_a = Util.InvertSorter(Util.CreateFieldSorter('a'))
 
@@ -42,7 +45,7 @@ local someRow = {
 table.addRow(someRow)
 
 local updateCounter = 0
-local watch = table.watchIndexRange('a', function(iterator, reason) 
+local watch = table.watchIndexRange('a', function(iterator, reason)
     updateCounter = updateCounter + 1
 end, 1, 5)
 
@@ -55,11 +58,11 @@ assertSame(1, updateCounter)
 watch.update(1, 50)
 assertSame(2, updateCounter)
 
-table.updateRow(someRow, function() 
+table.updateRow(someRow, function()
     someRow.a = 400
 end)
 assertSame(3, updateCounter)
-table.updateRow(someRow, function() 
+table.updateRow(someRow, function()
     someRow.a = 400
 end)
 assertSame(4, updateCounter)
@@ -73,4 +76,80 @@ watch.resume()
 assertSame(5, updateCounter)
 
 
-printResultsAndExit()
+-- test nonexistent index
+assertError(function()
+table.watchIndexRange('test', function() end)
+end)
+
+
+
+
+-- unique indexes are faster but dont support index range watches
+-- test this with a model type table that CLM uses:
+
+local Raid = {} -- Raid information
+function Raid:New(uid, name, roster, config, creator, entry)
+    local o = {}
+
+    setmetatable(o, self)
+    self.__index = self
+
+    o.entry = entry
+
+    -- Raid Management
+    o.uid  = uid
+    o.roster = roster
+
+    o.config = config
+    o.name = name
+    o.status = "CREATED"
+    -- o.owner = creator
+
+    o.startTime = 0
+    o.endTime = 0
+
+    -- GUID dict
+    -- Dynamic status of tje raid
+    o.players = { [creator] = true } -- for raid mangement we check sometimes if creator is part of raid
+    o.standby = { }
+
+    -- Historical storage of the raid
+    o.participated = {
+        inRaid = {},
+        standby = {}
+    }
+
+    return o
+end
+
+function Raid:UID()
+    return self.uid
+end
+
+function Raid:Name()
+    return self.name
+end
+
+local raids = Table.new({
+    name = function(raid) return raid:Name() end,
+    uid = test
+})
+
+local A = {}
+A.__index = A
+function A:new()
+    local o = {}
+    setmetatable(o, self)
+
+    return o
+end
+
+function A:test()
+
+print("test")
+end
+
+local a = A:new()
+print(a:test())
+
+printResultsAndExit()
\ No newline at end of file