initial commit
This commit is contained in:
Gitea
671
LibTSM/Service/AuctionScanClasses/ResultRow.lua
Normal file
671
LibTSM/Service/AuctionScanClasses/ResultRow.lua
Normal file
@@ -0,0 +1,671 @@
|
||||
-- ------------------------------------------------------------------------------ --
|
||||
-- TradeSkillMaster --
|
||||
-- https://tradeskillmaster.com --
|
||||
-- All Rights Reserved - Detailed license information included with addon. --
|
||||
-- ------------------------------------------------------------------------------ --
|
||||
|
||||
local _, TSM = ...
|
||||
local ResultRow = TSM.Init("Service.AuctionScanClasses.ResultRow")
|
||||
local ItemString = TSM.Include("Util.ItemString")
|
||||
local ObjectPool = TSM.Include("Util.ObjectPool")
|
||||
local TempTable = TSM.Include("Util.TempTable")
|
||||
local Table = TSM.Include("Util.Table")
|
||||
local ItemInfo = TSM.Include("Service.ItemInfo")
|
||||
local LibTSMClass = TSM.Include("LibTSMClass")
|
||||
local Util = TSM.Include("Service.AuctionScanClasses.Util")
|
||||
local AuctionHouseWrapper = TSM.Include("Service.AuctionHouseWrapper")
|
||||
local ResultSubRow = TSM.Include("Service.AuctionScanClasses.ResultSubRow")
|
||||
local ResultRowWrapper = LibTSMClass.DefineClass("ResultRowWrapper")
|
||||
local private = {
|
||||
objectPool = ObjectPool.New("AUCTION_SCAN_RESULT_ROW", ResultRowWrapper),
|
||||
}
|
||||
local SUB_ROW_SEARCH_INDEX_MULTIPLIER = 1000000
|
||||
|
||||
|
||||
|
||||
-- ============================================================================
|
||||
-- Module Functions
|
||||
-- ============================================================================
|
||||
|
||||
function ResultRow.Get(query, itemKey, minPrice, totalQuantity)
|
||||
local row = private.objectPool:Get()
|
||||
row:_Acquire(query, itemKey, minPrice, totalQuantity)
|
||||
return row
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- ============================================================================
|
||||
-- ResultRowWrapper - Meta Class Methods
|
||||
-- ============================================================================
|
||||
|
||||
function ResultRowWrapper.__init(self)
|
||||
self._query = nil
|
||||
self._items = {}
|
||||
self._baseItemString = nil
|
||||
self._canHaveNonBaseItemString = nil
|
||||
self._minPrice = nil
|
||||
self._hasItemInfo = nil
|
||||
self._isCommodity = nil
|
||||
self._notFiltered = false
|
||||
self._searchIndex = nil
|
||||
self._subRows = {}
|
||||
self._minBrowseId = nil
|
||||
end
|
||||
|
||||
function ResultRowWrapper._Acquire(self, query, item, minPrice, totalQuantity)
|
||||
self._query = query
|
||||
if TSM.IsWowClassic() then
|
||||
assert(not minPrice and not totalQuantity)
|
||||
tinsert(self._items, item)
|
||||
self._baseItemString = ItemString.GetBase(item)
|
||||
else
|
||||
item._minPrice = minPrice
|
||||
item._totalQuantity = totalQuantity
|
||||
tinsert(self._items, item)
|
||||
self._baseItemString = ItemString.GetBaseFromItemKey(item)
|
||||
end
|
||||
self._canHaveNonBaseItemString = nil
|
||||
self._minPrice = nil
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- ============================================================================
|
||||
-- ResultRowWrapper - Public Class Methods
|
||||
-- ============================================================================
|
||||
|
||||
function ResultRowWrapper.Merge(self, item, minPrice, totalQuantity)
|
||||
-- check if we already have this item
|
||||
for i = 1, #self._items do
|
||||
if item == self._items[i] then
|
||||
return
|
||||
end
|
||||
if type(item) == "table" then
|
||||
local isEqual = true
|
||||
for k in pairs(item) do
|
||||
if item[k] ~= self._items[i][k] then
|
||||
isEqual = false
|
||||
break
|
||||
end
|
||||
end
|
||||
if isEqual then
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
self._hasItemInfo = nil
|
||||
if TSM.IsWowClassic() then
|
||||
assert(not minPrice and not totalQuantity)
|
||||
assert(self._baseItemString == ItemString.GetBase(item))
|
||||
tinsert(self._items, item)
|
||||
self._notFiltered = false
|
||||
else
|
||||
assert(self._baseItemString == ItemString.GetBaseFromItemKey(item))
|
||||
item._minPrice = minPrice
|
||||
item._totalQuantity = totalQuantity
|
||||
tinsert(self._items, item)
|
||||
self._notFiltered = false
|
||||
end
|
||||
self._canHaveNonBaseItemString = nil
|
||||
end
|
||||
|
||||
function ResultRowWrapper.Release(self)
|
||||
wipe(self._items)
|
||||
self._baseItemString = nil
|
||||
self._canHaveNonBaseItemString = nil
|
||||
self._minPrice = nil
|
||||
self._hasItemInfo = nil
|
||||
self._isCommodity = nil
|
||||
self._notFiltered = false
|
||||
self._searchIndex = nil
|
||||
self._minBrowseId = nil
|
||||
for _, subRow in pairs(self._subRows) do
|
||||
subRow:Release()
|
||||
end
|
||||
wipe(self._subRows)
|
||||
private.objectPool:Recycle(self)
|
||||
end
|
||||
|
||||
function ResultRowWrapper.IsSubRow(self)
|
||||
return false
|
||||
end
|
||||
|
||||
function ResultRowWrapper.PopulateBrowseData(self)
|
||||
assert(self._baseItemString)
|
||||
if self._hasItemInfo then
|
||||
-- already have our item info
|
||||
return true
|
||||
elseif not Util.HasItemInfo(self._baseItemString) then
|
||||
-- don't have item info yet
|
||||
return false
|
||||
end
|
||||
|
||||
if not TSM.IsWowClassic() then
|
||||
-- cache the commodity status since it's referenced a ton
|
||||
if self._isCommodity == nil then
|
||||
self._isCommodity = ItemInfo.IsCommodity(self._baseItemString)
|
||||
assert(self._isCommodity ~= nil)
|
||||
end
|
||||
end
|
||||
|
||||
-- check if we have info for all the items and try to fetch it if not
|
||||
local missingInfo = false
|
||||
for _, item in ipairs(self._items) do
|
||||
if TSM.IsWowClassic() then
|
||||
if not Util.HasItemInfo(ItemString.Get(item)) then
|
||||
missingInfo = true
|
||||
end
|
||||
else
|
||||
if not item._itemKeyInfo then
|
||||
item._itemKeyInfo = C_AuctionHouse.GetItemKeyInfo(item, true)
|
||||
if not item._itemKeyInfo then
|
||||
missingInfo = true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if missingInfo then
|
||||
return false
|
||||
end
|
||||
|
||||
self._hasItemInfo = true
|
||||
return true
|
||||
end
|
||||
|
||||
function ResultRowWrapper.IsFiltered(self, query)
|
||||
assert(#self._items > 0)
|
||||
if self._notFiltered then
|
||||
return false
|
||||
end
|
||||
|
||||
-- check if the whole row is filtered
|
||||
if query:_IsFiltered(self, false) then
|
||||
return true
|
||||
end
|
||||
|
||||
-- filter our items
|
||||
for i = #self._items, 1, -1 do
|
||||
if query:_IsFiltered(self, false, self._items[i]) then
|
||||
tremove(self._items, i)
|
||||
end
|
||||
end
|
||||
self._canHaveNonBaseItemString = nil
|
||||
self._minPrice = nil
|
||||
if #self._items == 0 then
|
||||
-- no more items, so the entire row is filtered
|
||||
return true
|
||||
end
|
||||
|
||||
-- not filtered (cache this result)
|
||||
self._notFiltered = true
|
||||
return false
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SearchReset(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
assert(#self._items > 0)
|
||||
self._searchIndex = 1
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SearchNext(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
assert(self._searchIndex)
|
||||
if self._searchIndex == #self._items then
|
||||
self._searchIndex = nil
|
||||
return false
|
||||
end
|
||||
self._searchIndex = self._searchIndex + 1
|
||||
return true
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SearchIsReady(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
assert(self._searchIndex)
|
||||
-- the client needs to have the item key info cached before we can run the search
|
||||
return C_AuctionHouse.GetItemKeyInfo(self._items[self._searchIndex], true) and true or false
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SearchSend(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
assert(self._searchIndex)
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
-- send a sell query if we don't have browse results for the itemKey
|
||||
-- for some reason sell queries don't work for commodities or pets
|
||||
local isSellQuery = not self._isCommodity and not ItemString.IsPet(self._baseItemString) and not itemKey._totalQuantity
|
||||
return AuctionHouseWrapper.SendSearchQuery(itemKey, isSellQuery)
|
||||
end
|
||||
|
||||
function ResultRowWrapper.HasCachedSearchData(self)
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
if self._isCommodity then
|
||||
return C_AuctionHouse.HasFullCommoditySearchResults(itemKey.itemID)
|
||||
else
|
||||
return C_AuctionHouse.HasFullItemSearchResults(itemKey)
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SearchCheckStatus(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
assert(self._searchIndex)
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
|
||||
-- check if we have the full results
|
||||
local hasFullResults = nil
|
||||
if self._isCommodity then
|
||||
hasFullResults = C_AuctionHouse.HasFullCommoditySearchResults(itemKey.itemID)
|
||||
else
|
||||
hasFullResults = C_AuctionHouse.HasFullItemSearchResults(itemKey)
|
||||
end
|
||||
if hasFullResults then
|
||||
return true
|
||||
end
|
||||
|
||||
-- request more results
|
||||
if self._isCommodity then
|
||||
return false, AuctionHouseWrapper.RequestMoreCommoditySearchResults(itemKey.itemID)
|
||||
else
|
||||
return false, AuctionHouseWrapper.RequestMoreItemSearchResults(itemKey)
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.PopulateSubRows(self, browseId, index, itemLink)
|
||||
if TSM.IsWowClassic() then
|
||||
-- remove any prior results with a different browseId
|
||||
assert(index and not self._searchIndex)
|
||||
local subRow = ResultSubRow.Get(self)
|
||||
subRow:_SetRawData(index, browseId, itemLink)
|
||||
local _, hashNoSeller = subRow:GetHashes()
|
||||
if self._minBrowseId and self._minBrowseId ~= browseId then
|
||||
-- check if this subRow already exists with a prior browseId
|
||||
for i, existingSubRow in ipairs(self._subRows) do
|
||||
local _, existingHashNoSeller = existingSubRow:GetHashes()
|
||||
local _, _, existingBrowseId = existingSubRow:GetListingInfo()
|
||||
if hashNoSeller == existingHashNoSeller and browseId ~= existingBrowseId then
|
||||
-- replace the existing subRow
|
||||
existingSubRow:Release()
|
||||
self._subRows[i] = subRow
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
tinsert(self._subRows, subRow)
|
||||
else
|
||||
assert(self._searchIndex and not index)
|
||||
local subRowOffset = self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
local numAuctions = nil
|
||||
if self:IsCommodity() then
|
||||
numAuctions = C_AuctionHouse.GetNumCommoditySearchResults(itemKey.itemID)
|
||||
else
|
||||
numAuctions = C_AuctionHouse.GetNumItemSearchResults(itemKey)
|
||||
end
|
||||
if itemKey._numAuctions and numAuctions ~= itemKey._numAuctions then
|
||||
-- the results changed so clear out our existing data
|
||||
for i = itemKey._numAuctions, 1, -1 do
|
||||
if i > numAuctions then
|
||||
self._subRows[subRowOffset + i]:Release()
|
||||
self._subRows[subRowOffset + i] = nil
|
||||
else
|
||||
self._subRows[subRowOffset + i]:_SetRawData(nil)
|
||||
end
|
||||
end
|
||||
end
|
||||
itemKey._numAuctions = numAuctions
|
||||
for i = 1, numAuctions do
|
||||
self._subRows[subRowOffset + i] = self._subRows[subRowOffset + i] or ResultSubRow.Get(self)
|
||||
local subRow = self._subRows[subRowOffset + i]
|
||||
if not subRow:HasRawData() or not subRow:HasOwners() then
|
||||
local result = nil
|
||||
if self:IsCommodity() then
|
||||
result = C_AuctionHouse.GetCommoditySearchResultInfo(itemKey.itemID, i)
|
||||
else
|
||||
result = C_AuctionHouse.GetItemSearchResultInfo(itemKey, i)
|
||||
end
|
||||
subRow:_SetRawData(result, browseId)
|
||||
end
|
||||
end
|
||||
end
|
||||
self._minBrowseId = min(self._minBrowseId or math.huge, browseId)
|
||||
end
|
||||
|
||||
function ResultRowWrapper.FilterSubRows(self, query)
|
||||
local subRowOffset = TSM.IsWowClassic() and 0 or (self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||||
if TSM.IsWowClassic() then
|
||||
for i = #self._subRows, 1, -1 do
|
||||
if query:_IsFiltered(self._subRows[i], true) then
|
||||
self:_RemoveSubRowByIndex(i)
|
||||
end
|
||||
end
|
||||
else
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
for j = itemKey._numAuctions, 1, -1 do
|
||||
local subRow = self._subRows[subRowOffset + j]
|
||||
if query:_IsFiltered(subRow, true) then
|
||||
self:_RemoveSubRowByIndex(j)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- merge subRows with identical hashes
|
||||
local numSubRows = nil
|
||||
local hashIndexLookup = TempTable.Acquire()
|
||||
local index = 1
|
||||
while true do
|
||||
numSubRows = TSM.IsWowClassic() and #self._subRows or self._items[self._searchIndex]._numAuctions
|
||||
if index > numSubRows then
|
||||
break
|
||||
end
|
||||
local subRow = self._subRows[subRowOffset + index]
|
||||
local hash = subRow:GetHashes()
|
||||
local prevIndex = hashIndexLookup[hash]
|
||||
if prevIndex then
|
||||
-- there was a previous subRow with the same hash
|
||||
self._subRows[subRowOffset + prevIndex]:Merge(subRow)
|
||||
-- remove this subRow
|
||||
self:_RemoveSubRowByIndex(index)
|
||||
else
|
||||
hashIndexLookup[hash] = index
|
||||
index = index + 1
|
||||
end
|
||||
end
|
||||
TempTable.Release(hashIndexLookup)
|
||||
return numSubRows == 0
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetNumSubRows(self)
|
||||
if TSM.IsWowClassic() then
|
||||
return #self._subRows
|
||||
else
|
||||
local result = 0
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
result = result + (itemKey._numAuctions or 0)
|
||||
end
|
||||
return result
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.SubRowIterator(self, searchOnly)
|
||||
if TSM.IsWowClassic() then
|
||||
return ipairs(self._subRows)
|
||||
else
|
||||
if searchOnly then
|
||||
local result = TempTable.Acquire()
|
||||
assert(self._searchIndex)
|
||||
for i = 1, self._items[self._searchIndex]._numAuctions do
|
||||
local subRow = self._subRows[self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + i]
|
||||
assert(subRow)
|
||||
tinsert(result, subRow)
|
||||
end
|
||||
return TempTable.Iterator(result)
|
||||
else
|
||||
return private.SubRowIteratorHelper, self, SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.IsCommodity(self)
|
||||
assert(self._isCommodity ~= nil)
|
||||
return self._isCommodity
|
||||
end
|
||||
|
||||
function ResultRowWrapper.HasItemInfo(self)
|
||||
return self._hasItemInfo
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetBaseItemString(self)
|
||||
return self._baseItemString
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetItemString(self)
|
||||
if TSM.IsWowClassic() or not self._hasItemInfo or self._canHaveNonBaseItemString then
|
||||
return nil
|
||||
end
|
||||
if self._canHaveNonBaseItemString == nil then
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
if ItemInfo.CanHaveVariations(self._baseItemString) or itemKey.battlePetSpeciesID ~= 0 or itemKey.itemSuffix ~= 0 or itemKey.itemLevel ~= 0 then
|
||||
-- this item can have variations, so we don't know its itemString
|
||||
self._canHaveNonBaseItemString = true
|
||||
return nil
|
||||
end
|
||||
end
|
||||
self._canHaveNonBaseItemString = false
|
||||
end
|
||||
return self._baseItemString
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetItemInfo(self, itemKey)
|
||||
if TSM.IsWowClassic() or not self._hasItemInfo then
|
||||
return nil, nil, nil, nil
|
||||
end
|
||||
itemKey = itemKey or (#self._items == 1 and self._items[1] or nil)
|
||||
assert(not itemKey or itemKey._itemKeyInfo)
|
||||
local baseItemString = self:GetBaseItemString()
|
||||
local itemString = self:GetItemString()
|
||||
local itemName, quality, itemLevel, maxItemLevel = nil, nil, nil, nil
|
||||
if itemString then
|
||||
-- this item can't have variations, so we can know the name / level / quality
|
||||
itemName = ItemInfo.GetName(baseItemString)
|
||||
itemLevel = ItemInfo.GetItemLevel(baseItemString)
|
||||
quality = ItemInfo.GetQuality(baseItemString)
|
||||
assert(itemName and itemLevel and quality)
|
||||
else
|
||||
if itemKey and not itemKey._totalQuantity then
|
||||
-- if we didn't do a browse, then don't use this itemKey
|
||||
itemKey = nil
|
||||
end
|
||||
if itemKey then
|
||||
-- grab the name from the itemKeyInfo
|
||||
itemName = itemKey._itemKeyInfo.itemName
|
||||
assert(itemName)
|
||||
end
|
||||
local hasSingleAuction = itemKey and itemKey._totalQuantity == 1
|
||||
if hasSingleAuction then
|
||||
-- grab the quality from the itemKeyInfo since there's only one listing
|
||||
quality = itemKey._itemKeyInfo.quality
|
||||
assert(quality)
|
||||
end
|
||||
if not ItemString.IsPet(self._baseItemString) then
|
||||
-- for non-pets, we can maybe grab the itemLevel from the itemKey
|
||||
if itemKey then
|
||||
itemLevel = itemKey.itemLevel ~= 0 and itemKey.itemLevel or nil
|
||||
else
|
||||
-- only use the itemLevel from the itemKeys if they are all the same
|
||||
local itemKeyItemLevel = self._items[1].itemLevel
|
||||
for i = 2, #self._items do
|
||||
if self._items[i].itemLevel ~= itemKeyItemLevel then
|
||||
itemKeyItemLevel = nil
|
||||
break
|
||||
end
|
||||
end
|
||||
itemLevel = (itemKeyItemLevel or 0) ~= 0 and itemKeyItemLevel or nil
|
||||
end
|
||||
elseif itemKey and itemKey._itemKeyInfo.battlePetLink then
|
||||
if hasSingleAuction then
|
||||
-- grab the itemLevel from the link since there's only one listing
|
||||
itemLevel = ItemInfo.GetItemLevel(itemKey._itemKeyInfo.battlePetLink)
|
||||
assert(itemLevel)
|
||||
else
|
||||
-- grab the maxItemLevel from the link
|
||||
maxItemLevel = ItemInfo.GetItemLevel(itemKey._itemKeyInfo.battlePetLink)
|
||||
assert(maxItemLevel)
|
||||
end
|
||||
end
|
||||
end
|
||||
return itemName, quality, itemLevel, maxItemLevel
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetBuyouts(self, resultItemKey)
|
||||
if TSM.IsWowClassic() then
|
||||
return nil, nil, nil
|
||||
end
|
||||
assert(#self._items > 0)
|
||||
if resultItemKey then
|
||||
return nil, nil, resultItemKey._minPrice
|
||||
else
|
||||
if self._minPrice == nil then
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
if not itemKey._minPrice then
|
||||
self._minPrice = -1
|
||||
return nil, nil, nil
|
||||
end
|
||||
self._minPrice = min(self._minPrice or math.huge, itemKey._minPrice)
|
||||
end
|
||||
elseif self._minPrice == -1 then
|
||||
return nil, nil, nil
|
||||
end
|
||||
return nil, nil, self._minPrice
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetQuantities(self)
|
||||
local totalQuantity = 0
|
||||
if TSM.IsWowClassic() then
|
||||
for _, subRow in ipairs(self._subRows) do
|
||||
local quantity, numAuctions = subRow:GetQuantities()
|
||||
totalQuantity = totalQuantity + quantity * numAuctions
|
||||
end
|
||||
else
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
if not itemKey._totalQuantity then
|
||||
return
|
||||
end
|
||||
totalQuantity = totalQuantity + itemKey._totalQuantity
|
||||
end
|
||||
end
|
||||
return totalQuantity, 1
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetMaxQuantities(self)
|
||||
assert(self:IsCommodity())
|
||||
local totalQuantity = 0
|
||||
for _, subRow in self:SubRowIterator() do
|
||||
local _, numOwnerItems = subRow:GetOwnerInfo()
|
||||
local quantityAvailable = subRow:GetQuantities() - numOwnerItems
|
||||
totalQuantity = totalQuantity + quantityAvailable
|
||||
end
|
||||
return totalQuantity
|
||||
end
|
||||
|
||||
function ResultRowWrapper.RemoveSubRow(self, subRow)
|
||||
local index = Table.KeyByValue(self._subRows, subRow)
|
||||
if TSM.IsWowClassic() then
|
||||
self:_RemoveSubRowByIndex(index)
|
||||
else
|
||||
local searchIndex = floor(index / SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||||
index = index % SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||||
assert(self._subRows[searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + index] == subRow)
|
||||
local prevSearchIndex = self._searchIndex
|
||||
self._searchIndex = searchIndex
|
||||
self:_RemoveSubRowByIndex(index)
|
||||
self._searchIndex = prevSearchIndex
|
||||
end
|
||||
self._query:_OnSubRowRemoved(self)
|
||||
end
|
||||
|
||||
function ResultRowWrapper.WipeSearchResults(self)
|
||||
wipe(self._subRows)
|
||||
if not TSM.IsWowClassic() then
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
itemKey._numAuctions = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetQuery(self)
|
||||
return self._query
|
||||
end
|
||||
|
||||
function ResultRowWrapper.DecrementQuantity(self, amount)
|
||||
assert(self:IsCommodity() and not TSM.IsWowClassic() and #self._items == 1)
|
||||
local index = 1
|
||||
while amount > 0 do
|
||||
local subRow = self._subRows[index + SUB_ROW_SEARCH_INDEX_MULTIPLIER]
|
||||
assert(subRow)
|
||||
local _, numOwnerItems = subRow:GetOwnerInfo()
|
||||
local quantityAvailable = subRow:GetQuantities() - numOwnerItems
|
||||
if quantityAvailable > 0 then
|
||||
local usedQuantity = min(quantityAvailable, amount)
|
||||
local prevItemBuyout = floor(subRow._buyout / subRow._quantity)
|
||||
amount = amount - usedQuantity
|
||||
subRow._quantity = subRow._quantity - usedQuantity
|
||||
subRow._buyout = prevItemBuyout * subRow._quantity
|
||||
subRow._minBid = subRow._buyout
|
||||
if numOwnerItems == 0 and subRow._quantity == 0 then
|
||||
self:RemoveSubRow(subRow)
|
||||
else
|
||||
index = index + 1
|
||||
end
|
||||
else
|
||||
index = index + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper.GetMinBrowseId(self)
|
||||
return self._minBrowseId
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- ============================================================================
|
||||
-- ResultRowWrapper - Private Class Methods
|
||||
-- ============================================================================
|
||||
|
||||
function ResultRowWrapper._RemoveSubRowByIndex(self, index)
|
||||
if TSM.IsWowClassic() then
|
||||
self._subRows[index]:Release()
|
||||
tremove(self._subRows, index)
|
||||
else
|
||||
local subRowOffset = self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||||
local itemKey = self._items[self._searchIndex]
|
||||
self._subRows[subRowOffset + index]:Release()
|
||||
self._subRows[subRowOffset + index] = nil
|
||||
-- shift the other subRows for this item down
|
||||
for i = index, itemKey._numAuctions - 1 do
|
||||
self._subRows[subRowOffset + i] = self._subRows[subRowOffset + i + 1]
|
||||
end
|
||||
self._subRows[subRowOffset + itemKey._numAuctions] = nil
|
||||
itemKey._numAuctions = itemKey._numAuctions - 1
|
||||
end
|
||||
end
|
||||
|
||||
function ResultRowWrapper._GetSearchProgress(self)
|
||||
assert(not TSM.IsWowClassic())
|
||||
if #self._items == 0 then
|
||||
return 0
|
||||
end
|
||||
local numSearched = 0
|
||||
for _, itemKey in ipairs(self._items) do
|
||||
if itemKey._numAuctions then
|
||||
numSearched = numSearched + 1
|
||||
end
|
||||
end
|
||||
return numSearched / #self._items
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- ============================================================================
|
||||
-- Private Helper Functions
|
||||
-- ============================================================================
|
||||
|
||||
function private.SubRowIteratorHelper(row, index)
|
||||
local searchIndex = floor(index / SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||||
local subRowIndex = index % SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||||
while true do
|
||||
local itemKey = row._items[searchIndex]
|
||||
if not itemKey then
|
||||
return
|
||||
end
|
||||
|
||||
if subRowIndex >= (itemKey._numAuctions or 0) then
|
||||
searchIndex = searchIndex + 1
|
||||
subRowIndex = 0
|
||||
else
|
||||
subRowIndex = subRowIndex + 1
|
||||
index = searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + subRowIndex
|
||||
return index, row._subRows[index]
|
||||
end
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user