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