@quenty/observablecollection 12.11.1 → 12.12.0

package/src/Shared/{ObservableSortedList.lua → SortedList/ObservableSortedListOld.lua}

@@ -60,13 +60,12 @@ function ObservableSortedList.new(isReversed, compare)
 
 	self._indexObservers = self._maid:Add(ObservableSubscriptionTable.new())
 	self._contentIndexObservers = self._maid:Add(ObservableSubscriptionTable.new())
+	self._keyObservables = self._maid:Add(ObservableSubscriptionTable.new())
 
 	self._sortValue = {} -- { [Symbol]: number }
 	self._contents = {} -- { [Symbol]: T }
 	self._indexes = {} -- { [Symbol]: number }
 
-	self._keyObservables = {} -- { [Symbol]: { Subscription } }
-
 	self._isReversed = isReversed or false
 	self._compare = compare or defaultCompare
 
@@ -124,6 +123,19 @@ function ObservableSortedList:Observe()
 	})
 end
 
+--[=[
+	Allows iteration over the observable map
+
+	@return (T) -> ((T, nextIndex: any) -> ...any, T?)
+]=]
+function ObservableSortedList:__iter()
+	return coroutine.wrap(function()
+		for index, value in self._keyList do
+			coroutine.yield(index, self._contents[value])
+		end
+	end)
+end
+
 function ObservableSortedList:Contains(value)
 	-- TODO: Binary search
 	for _, item in pairs(self._contents) do
@@ -239,33 +251,16 @@ end
 function ObservableSortedList:ObserveIndexByKey(key)
 	assert(Symbol.isSymbol(key), "Bad key")
 
-	return Observable.new(function(sub)
-		local maid = Maid.new()
-		self._keyObservables[key] = self._keyObservables[key] or {}
-		table.insert(self._keyObservables[key], sub)
-
-		local currentIndex = self._indexes[key]
-		if currentIndex then
-			sub:Fire(currentIndex)
-		end
-
-		maid:GiveTask(function()
-			local list = self._keyObservables[key]
-			if not list then
-				return
-			end
-
-			local index = table.find(list, sub)
-			if index then
-				table.remove(list, index)
-				if #list == 0 then
-					self._keyObservables[key] = nil
-				end
+	return self._keyObservables:Observe(key):Pipe({
+		Rx.startFrom(function()
+			local currentIndex = self._indexes[key]
+			if currentIndex then
+				return { currentIndex }
+			else
+				return {}
 			end
-		end)
-
-		return maid
-	end)
+		end);
+	})
 end
 
 --[=[
@@ -337,15 +332,10 @@ function ObservableSortedList:Add(item, observeValue)
 	end
 
 	maid:GiveTask(function()
-		local observableSubs = self._keyObservables[key]
-		self._keyObservables[key] = nil
-
 		self:_removeItemByKey(key, item)
 
 		-- Fire off the index change on the value
-		if observableSubs then
-			self:_completeSubs(observableSubs)
-		end
+		self._keyObservables:Complete(key)
 
 		self._contents[key] = nil
 		self._sortValue[key] = nil
@@ -359,7 +349,7 @@ function ObservableSortedList:Add(item, observeValue)
 end
 
 function ObservableSortedList:_assignSortValue(key, item, sortValue)
-	self:_debugVerifyIntegrity()
+	-- self:_debugVerifyIntegrity()
 
 	if sortValue ~= nil then
 		local currentIndex = self._indexes[key]
@@ -368,18 +358,12 @@ function ObservableSortedList:_assignSortValue(key, item, sortValue)
 		self._sortValue[key] = sortValue
 		self:_updateIndex(key, item, targetIndex, sortValue)
 	else
-		local observableSubs = self._keyObservables[key]
-
 		-- calling this also may unsubscribe some observables.
 		self:_removeItemByKey(key, item)
-
-		if observableSubs then
-			-- fire nil index
-			self:_fireSubs(observableSubs, nil)
-		end
+		self._keyObservables:Complete(key)
 	end
 
-	self:_debugVerifyIntegrity()
+	-- 	self:_debugVerifyIntegrity()
 end
 
 
@@ -596,11 +580,7 @@ function ObservableSortedList:_queueDeferredChange()
 				if self._indexes[lastChange.key] == lastChange.newIndex then
 					changed = true
 
-					local subs = self._keyObservables[lastChange.key]
-					if subs then
-						self:_fireSubs(subs, lastChange.newIndex)
-					end
-
+					self._keyObservables:Fire(lastChange.key, lastChange.newIndex)
 					self._indexObservers:Fire(lastChange.newIndex, self._contents[lastChange.key])
 				end
 			end
@@ -682,7 +662,9 @@ function ObservableSortedList:_lowBinarySearch(sortValue)
 	while true do
 		local mid = math.floor((minIndex + maxIndex) / 2)
 		local compareValue = self._compare(self._sortValue[self._keyList[mid]], sortValue)
-		assert(type(compareValue) == "number", "Expecting number")
+		if type(compareValue) ~= "number" then
+			error(string.format("Bad compareValue, expected number, got %q", type(compareValue)))
+		end
 
 		if self._isReversed then
 			compareValue = -compareValue
@@ -702,16 +684,6 @@ function ObservableSortedList:_lowBinarySearch(sortValue)
 	end
 end
 
-function ObservableSortedList:_debugSortValuesToString()
-	local values = {}
-
-	for _, key in pairs(self._keyList) do
-		table.insert(values, string.format("%4d", self._sortValue[key]))
-	end
-
-	return table.concat(values, ", ")
-end
-
 function ObservableSortedList:_debugVerifyIntegrity()
 	for i=2, #self._keyList do
 		local compare = self._compare(self._sortValue[self._keyList[i-1]], self._sortValue[self._keyList[i]])
@@ -730,23 +702,14 @@ function ObservableSortedList:_debugVerifyIntegrity()
 	end
 end
 
-function ObservableSortedList:_fireSubs(list, index)
-	for _, sub in pairs(list) do
-		if sub:IsPending() then
-			task.spawn(function()
-				sub:Fire(index)
-			end)
-		end
-	end
-end
+function ObservableSortedList:_debugSortValuesToString()
+	local values = {}
 
-function ObservableSortedList:_completeSubs(list)
-	for _, sub in pairs(list) do
-		if sub:IsPending() then
-			sub:Fire(nil)
-			sub:Complete()
-		end
+	for _, key in pairs(self._keyList) do
+		table.insert(values, string.format("%4d", self._sortValue[key]))
 	end
+
+	return table.concat(values, ", ")
 end
 
 --[=[

package/src/Shared/SortedList/ObservableSortedList_Performance.story.lua

@@ -0,0 +1,74 @@
+--[[
+	@class ObservableSortedList.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Maid = require("Maid")
+local ObservableSortedList = require("ObservableSortedList")
+local ObservableSortedListOld = require("ObservableSortedListOld")
+
+return function(_target)
+	local maid = Maid.new()
+
+	local function test(n, label, sortedList, getElement)
+		local function add(number)
+			sortedList:Add(tostring(number), number)
+		end
+
+		local startTime = os.clock()
+		for i=1, n do
+			add(getElement(i))
+		end
+
+		print(string.format("%25s %0.2f ms", label .. " construction", (os.clock() - startTime)*1000))
+	end
+
+
+	local function cleanup(label, sortedList)
+		local startTime = os.clock()
+
+		sortedList:Destroy()
+
+		print(string.format("%25s %0.2f ms", label .. " destruction", (os.clock() - startTime)*1000))
+	end
+
+
+	local function getRandomElement()
+		return math.random()
+	end
+
+	local function inOrder(i)
+		return i
+	end
+
+	local function same()
+		return 0
+	end
+
+	local function runTest(label, n, getElement)
+		local observableSortedList = maid:Add(ObservableSortedList.new())
+		local observableSortedListOld = maid:Add(ObservableSortedListOld.new())
+
+		print(string.format("%25s n = %d", label, n))
+		print(string.format("%25s %8s", string.rep("-", 25), string.rep("-", 10)))
+
+		test(n, "prev impl", observableSortedListOld, getElement)
+		cleanup("prev impl", observableSortedListOld)
+
+		test(n, "new impl", observableSortedList, getElement)
+		cleanup("new impl", observableSortedList)
+
+
+		print("\n")
+	end
+
+	local n = 1000
+	runTest("test random_order", n, getRandomElement)
+	runTest("test in_order", n, inOrder)
+	runTest("same", n, same)
+
+	return function()
+		maid:DoCleaning()
+	end
+end

package/src/Shared/SortedList/ObservableSortedList_Print.story.lua

@@ -0,0 +1,65 @@
+--[[
+	@class ObservableSortedList.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Maid = require("Maid")
+local ObservableSortedList = require("ObservableSortedList")
+
+return function(_target)
+	local maid = Maid.new()
+
+	print("----")
+
+	task.spawn(function()
+		local observableSortedList = maid:Add(ObservableSortedList.new())
+
+		local toRemove = {}
+
+		local function add(number)
+			table.insert(toRemove, observableSortedList:Add(tostring(number), number))
+		end
+
+		-- local random = Random.new(5000)
+		-- for i=1, 10 do
+		-- 	add(random:NextNumber())
+		-- end
+
+		local random = Random.new()
+		for _i=1, 10 do
+			add(math.floor(100*random:NextNumber()))
+		end
+
+		for index, node in observableSortedList._root:IterateNodesRange(3, 7) do
+			print(index, node:GetIndex())
+		end
+
+		observableSortedList:PrintDebug()
+
+		for _, item in toRemove do
+			item()
+		end
+
+		-- observableSortedList:PrintDebug()
+		observableSortedList:Destroy()
+	end)
+
+		-- for i=1, 10 do
+		-- 	add(-i)
+		-- 	add(i)
+		-- end
+
+		-- add(2)
+		-- add(1)
+		-- add(3)
+		-- add(4)
+		-- add(5)
+		-- add(0)
+
+		-- print(observableSortedList:GetList())
+
+	return function()
+		maid:DoCleaning()
+	end
+end

package/src/Shared/SortedList/SortFunctionUtils.lua

@@ -0,0 +1,31 @@
+--[=[
+	@class SortFunctionUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local SortFunctionUtils = {}
+
+function SortFunctionUtils.reverse(compare)
+	compare = compare or SortFunctionUtils.default
+	return function(a, b)
+		return compare(b, a)
+	end
+end
+
+-- Higher numbers last
+function SortFunctionUtils.default(a, b)
+	-- equivalent of `return a - b` except it supports comparison of strings and stuff
+	if b > a then
+		return -1
+	elseif b < a then
+		return 1
+	else
+		return 0
+	end
+end
+
+function SortFunctionUtils.emptyIterator()
+end
+
+return SortFunctionUtils