1 files changed, 56 insertions, 27 deletions

diff --git a/indra/newview/scripts/lua/require/result_view.lua b/indra/newview/scripts/lua/require/result_view.lua
index c719681c66..5301d7838c 100644
--- a/indra/newview/scripts/lua/require/result_view.lua
+++ b/indra/newview/scripts/lua/require/result_view.lua
@@ -1,34 +1,36 @@
+local leap = require 'leap'
+
 -- metatable for every result_view() table
 local mt = {
-    __len = function(this)
-        return this.length
+    __len = function(self)
+        return self.length
     end,
-    __index = function(this, i)
+    __index = function(self, i)
         -- right away, convert to 0-relative indexing
         i -= 1
         -- can we find this index within the current slice?
-        local reli = i - this.start
-        if 0 <= reli and reli < #this.slice then
+        local reli = i - self.start
+        if 0 <= reli and reli < #self.slice then
             -- Lua 1-relative indexing
-            return this.slice[reli + 1]
+            return self.slice[reli + 1]
         end
         -- is this index outside the overall result set?
-        if not (0 <= i and i < this.length) then
+        if not (0 <= i and i < self.length) then
             return nil
         end
         -- fetch a new slice starting at i, using provided fetch()
         local start
-        this.slice, start = this.fetch(this.key, i)
+        self.slice, start = self.fetch(self.key, i)
         -- It's possible that caller-provided fetch() function forgot
         -- to return the adjusted start index of the new slice. In
         -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
-        -- we'll duly reset this.start to 0. Otherwise, assume the
+        -- we'll duly reset self.start to 0. Otherwise, assume the
         -- requested index was not adjusted: that the returned slice
         -- really does start at i.
-        this.start = start or i
+        self.start = start or i
         -- Hopefully this slice contains the desired i.
         -- Back to 1-relative indexing.
-        return this.slice[i - this.start + 1]
+        return self.slice[i - self.start + 1]
     end,
     -- We purposely avoid putting any array entries (int keys) into
     -- our table so that access to any int key will always call our
@@ -40,7 +42,7 @@ local mt = {
     -- This result set provides read-only access.
     -- We do not support pushing updates to individual items back to
     -- C++; for the intended use cases, that makes no sense.
-    __newindex = function(this, i, value)
+    __newindex = function(self, i, value)
         error("result_view is a read-only data structure", 2)
     end
 }
@@ -50,20 +52,47 @@ local mt = {
 -- access to the entire result set.
 -- key_length: {result set key, total result set length}
 -- fetch:      function(key, start) that returns (slice, adjusted start) 
-local function result_view(key_length, fetch)
-    return setmetatable(
-        {
-            key=key_length[1],
-            length=key_length[2],
-            -- C++ result sets use 0-based indexing, so internally we do too
-            start=0,
-            -- start with a dummy array with length 0
-            slice={},
-            fetch=fetch
-        },
-        -- use our special metatable
-        mt
-    )
-end
+local result_view = setmetatable(
+    {
+        -- generic fetch() function
+        fetch = function(key, start)
+            local fetched = leap.request(
+                'LLInventory',
+                {op='getSlice', result=key, index=start})
+            return fetched.slice, fetched.start
+        end,
+        -- generic close() function accepting variadic result-set keys
+        close = function(...)
+            local keys = table.pack(...)
+            -- table.pack() produces a table with an array entry for every
+            -- parameter, PLUS an 'n' key with the count. Unfortunately that
+            -- 'n' key bollixes our conversion to LLSD, which requires either
+            -- all int keys (for an array) or all string keys (for a map).
+            keys.n = nil
+            leap.send('LLInventory', {op='closeResult', result=keys})
+        end
+    },
+    {
+        -- result_view(key_length, fetch) calls this
+        __call = function(class, key_length, fetch)
+            return setmetatable(
+                {
+                    key=key_length[1],
+                    length=key_length[2],
+                    -- C++ result sets use 0-based indexing, so internally we do too
+                    start=0,
+                    -- start with a dummy array with length 0
+                    slice={},
+                    -- if caller didn't pass fetch() function, use generic
+                    fetch=fetch or class.fetch,
+                    -- returned view:close() will close result set with passed key
+                    close=function(self) class.close(key_length[1]) end
+                },
+                -- use our special metatable
+                mt
+            )
+        end
+    }
+)
 
 return result_view