Give certain LLInventory queries an API based on result sets.

Introduce abstract base class InvResultSet, derived from LLIntTracker so each
instance has a unique int key. InvResultSet supports virtual getLength() and
getSlice() operations. getSlice() returns an LLSD array limited to
MAX_ITEM_LIMIT result set entries. It permits retrieving a "slice" of the
contained result set starting at an arbitrary index. A sequence of getSlice()
calls can eventually retrieve a whole result set.

InvResultSet has subclasses CatResultSet containing cat_array_t, and
ItemResultSet containing item_array_t. Each implements a virtual method that
produces an LLSD map from a single array item.

Make LLInventoryListener::getItemsInfo(), getDirectDescendants() and
collectDescendantsIf() instantiate heap CatResultSet and ItemResultSet objects
containing the resultant LLPointer arrays, and return their int keys for
categories and items.

Add LLInventoryListener::getSlice() and closeResult() methods that accept the
int keys of result sets. getSlice() returns the requested LLSD array to its
caller, while closeResult() is fire-and-forget.

Because bulk data transfer is now performed by getSlice() rather than by
collectDescendantsIf(), change the latter's "limit" default to unlimited.
Allow the C++ code to collect an arbitrary number of LLPointer array entries,
as long as getSlice() limits retrieval overhead.

Spell "descendants" correctly, unlike the "descendents" spelling embedded in
the rest of the viewer... sigh. Make the Lua module provide both spellings.

Make MAX_ITEM_LIMIT a U32 instead of F32.

In LLInventory.lua, store int result set keys from 'getItemsInfo',
'getDirectDescendants' and 'collectDescendantsIf' in a table with a close()
function. The close() function invokes 'closeResult' with the bound int keys.

Give that table an __index() metamethod that recognizes only 'categories' and
'items' keys: anything else returns nil. For either of the recognized keys,
call 'getSlice' with the corresponding result set key to retrieve (the initial
slice of) the actual result set. Cache that result. Lazy retrieval means that
if the caller only cares about categories, or only about items, the other
result set need never be retrieved at all.

This is a first step: like the previous code, it still retrieves only up to
the first 100 result set entries. But the C++ code now supports retrieval of
additional slices, so extending result set retrieval is mostly Lua work.

Finally, wrap the table-with-metamethod in an LL.setdtor() proxy whose
destructor calls its close() method to tell LLInventoryListener to destroy the
CatResultSet and ItemResultSet with the bound keys.

1 files changed, 68 insertions, 11 deletions

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index dd1b910250..0ff6b9fb37 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -1,12 +1,66 @@
 local leap = require 'leap'
 local mapargs = require 'mapargs'
 
+local function result(keys)
+    return LL.setdtor(
+        'LLInventory result',
+        setmetatable(
+            -- the basic table wrapped by setmetatable just captures the int
+            -- result-set keys from 'keys', but with underscore prefixes
+            {
+                _categories=keys.categories,
+                _items=keys.items,
+                -- call result:close() to release result sets before garbage
+                -- collection or script completion
+                close = function(self)
+                    leap.send('LLInventory',
+                              {op='closeResult',
+                               result={self._categories, self._items}})
+                end
+            },
+            -- The caller of one of our methods that returns a result set
+            -- isn't necessarily interested in both categories and items, so
+            -- don't proactively populate both. Instead, when caller references
+            -- either 'categories' or 'items', the __index() metamethod
+            -- populates that field.
+            {
+                __index = function(t, key)
+                    -- we really don't care about references to any other field
+                    if not table.find({'categories', 'items'}, key) then
+                        return nil
+                    end
+                    -- We cleverly saved the int result set key in a field
+                    -- with the same name but an underscore prefix.
+                    local resultkey = t['_' .. key]
+                    -- TODO: This only ever fetches the FIRST slice. What we
+                    -- really want is to return a table with metamethods that
+                    -- manage indexed access and table iteration.
+                    -- Remember our C++ entry point uses 0-relative indexing.
+                    local slice = leap.request(
+                        'LLInventory',
+                        {op='getSlice', result=resultkey, index=0}).slice
+                    print(`getSlice({resultkey}, 0) => {slice} ({#slice} entries)`)
+                    -- cache this slice for future reference
+                    t[key] = slice
+                    return slice
+                end
+            }
+        ),
+        -- When the table-with-metatable above is destroyed, tell LLInventory
+        -- we're done with its result sets -- whether or not we ever fetched
+        -- either of them.
+        function(keys)
+            keys:close()
+        end
+    )
+end
+
 local LLInventory = {}
 
 -- Get the items/folders info by provided IDs,
 -- reply will contain "items" and "categories" tables accordingly
 function LLInventory.getItemsInfo(item_ids)
-    return leap.request('LLInventory', {op = 'getItemsInfo', item_ids=item_ids})
+    return result(leap.request('LLInventory', {op = 'getItemsInfo', item_ids=item_ids}))
 end
 
 -- Get the table of folder type names, which can be later used to get the ID of the basic folders
@@ -19,30 +73,33 @@ function LLInventory.getBasicFolderID(ft_name)
     return leap.request('LLInventory', {op = 'getBasicFolderID', ft_name=ft_name}).id
 end
 
--- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendentsIf(...)
+-- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendantsIf(...)
 function LLInventory.getAssetTypeNames()
     return leap.request('LLInventory', {op = 'getAssetTypeNames'}).names
 end
 
--- Get the direct descendents of the 'folder_id' provided,
+-- Get the direct descendants of the 'folder_id' provided,
 -- reply will contain "items" and "categories" tables accordingly
-function LLInventory.getDirectDescendents(folder_id)
-    return leap.request('LLInventory', {op = 'getDirectDescendents', folder_id=folder_id})
+function LLInventory.getDirectDescendants(folder_id)
+    return result(leap.request('LLInventory', {op = 'getDirectDescendants', folder_id=folder_id}))
 end
+-- backwards compatibility
+LLInventory.getDirectDescendents = LLInventory.getDirectDescendants
 
--- Get the descendents of the 'folder_id' provided, which pass specified filters
+-- Get the descendants of the 'folder_id' provided, which pass specified filters
 -- reply will contain "items" and "categories" tables accordingly
--- LLInventory.collectDescendentsIf{ folder_id   -- parent folder ID
+-- LLInventory.collectDescendantsIf{ folder_id   -- parent folder ID
 -- [, name]              -- name (substring)
 -- [, desc]              -- description (substring)
 -- [, type]              -- asset type
 -- [, limit]             -- item count limit in reply, maximum and default is 100
 -- [, filter_links]}     -- EXCLUDE_LINKS - don't show links, ONLY_LINKS - only show links, INCLUDE_LINKS - show links too (default)
-function LLInventory.collectDescendentsIf(...)
+function LLInventory.collectDescendantsIf(...)
     local args = mapargs('folder_id,name,desc,type,filter_links,limit', ...)
-    args.op = 'collectDescendentsIf'
-    return leap.request('LLInventory', args)
+    args.op = 'collectDescendantsIf'
+    return result(leap.request('LLInventory', args))
 end
-
+-- backwards compatibility
+LLInventory.collectDescendentsIf = LLInventory.collectDescendantsIf
 
 return LLInventory