rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/kernel/base/Dispatcher.lua

@@ -0,0 +1,99 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Object Request Dispatcher                                         --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- dispatcher:Facet
+-- 	success:boolean, [except:table]|results... dispatch(key:string, operation:string|function, params...)
+--------------------------------------------------------------------------------
+
+local luapcall     = pcall
+local setmetatable = setmetatable
+local type         = type
+local select       = select
+local unpack       = unpack
+
+local table       = require "loop.table"
+local oo          = require "oil.oo"
+local Exception   = require "oil.Exception"                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.base.Dispatcher", oo.class)
+
+pcall = luapcall
+
+context = false
+
+--------------------------------------------------------------------------------
+-- Dispatcher facet
+
+function dispatch(self, request)
+	local object, operation = request:preinvoke()
+	if object then
+		object = self.context.servants:retrieve(object)
+		if object then
+			local method = object[operation]
+			if method then                                                            --[[VERBOSE]] verbose:dispatcher("dispatching operation ",object,":",operation,request:params())
+				request:results(self.pcall(method, object, request:params()))
+			else                                                                      --[[VERBOSE]] verbose:dispatcher("missing implementation of ",opname)
+				request:results(false, Exception{
+					reason = "noimplement",
+					message = "no implementation for operation of object with key",
+					operation = operation,
+					object = object,
+					key = key,
+				})
+			end
+		else                                                                        --[[VERBOSE]] verbose:dispatcher("got illegal object ",key)
+			request:results(false, Exception{
+				reason = "badkey",
+				message = "no object with key",
+				key = key,
+			})
+		end
+	end
+end
+
+--------------------------------------------------------------------------------
+
+--[[VERBOSE]] function verbose.custom:dispatcher(...)
+--[[VERBOSE]] 	local params
+--[[VERBOSE]] 	for i = 1, select("#", ...) do
+--[[VERBOSE]] 		local value = select(i, ...)
+--[[VERBOSE]] 		local type = type(value)
+--[[VERBOSE]] 		if params == true then
+--[[VERBOSE]] 			params = "("
+--[[VERBOSE]] 			if type == "string" then
+--[[VERBOSE]] 				self.viewer.output:write(value)
+--[[VERBOSE]] 			else
+--[[VERBOSE]] 				self.viewer:write(value)
+--[[VERBOSE]] 			end
+--[[VERBOSE]] 		elseif type == "string" then
+--[[VERBOSE]] 			if params then
+--[[VERBOSE]] 				self.viewer.output:write(params)
+--[[VERBOSE]] 				params = ", "
+--[[VERBOSE]] 				self.viewer:write((value:gsub("[^%w%p%s]", "?")))
+--[[VERBOSE]] 			else
+--[[VERBOSE]] 				self.viewer.output:write(value)
+--[[VERBOSE]] 				if value == ":" then params = true end
+--[[VERBOSE]] 			end
+--[[VERBOSE]] 		else
+--[[VERBOSE]] 			if params then
+--[[VERBOSE]] 				self.viewer.output:write(params)
+--[[VERBOSE]] 				params = ", "
+--[[VERBOSE]] 			end
+--[[VERBOSE]] 			self.viewer:write(value)
+--[[VERBOSE]] 		end
+--[[VERBOSE]] 	end
+--[[VERBOSE]] 	if params then
+--[[VERBOSE]] 		self.viewer.output:write(params == "(" and "()" or ")")
+--[[VERBOSE]] 	end
+--[[VERBOSE]] end

data/vendor/lua/lib/lua/oil/kernel/base/Proxies.lua

@@ -0,0 +1,86 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Remote Object Proxies                                             --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- proxies:Facet
+-- 	proxy:object proxyto(reference:table)
+--
+-- invoker:Receptacle
+-- 	[results:object], [except:table] invoke(reference, operation, args...)
+--------------------------------------------------------------------------------
+
+local setmetatable = setmetatable
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.base.Proxies", oo.class)
+
+local function newclass(methodmaker)
+	return setmetatable(oo.initclass{
+		__tostring = proxytostring,
+	}, {
+		__mode = "v", -- TODO:[maia] can method creation/collection be worse than
+		              --             memory leak due to invocation of constantly
+		              --             changing methods ?
+		__call = oo.rawnew,
+		__index = function(cache, field)
+			local function invoker(self, ...)                                         --[[VERBOSE]] verbose:proxies("call to ",field," ", ...)
+				return self.__manager.requester:newrequest(self.__reference, field, ...)
+			end
+			invoker = methodmaker(invoker, field)
+			cache[field] = invoker
+			return invoker
+		end,
+	})
+end
+
+function __init(self, ...)
+	self = oo.rawnew(self, ...)
+	self.class = self.class or newclass(self.invoker)
+	return self
+end
+
+function fromstring(self, reference, ...)
+	local result, except = self.referrer:decode(reference)
+	if result then
+		result, except = self:resolve(result, ...)
+	end
+	return result, except
+end
+
+function resolve(self, reference, ...)                                          --[[VERBOSE]] verbose:proxies(true, "resolve reference for ",reference)
+	local result, except
+	local servants = self.servants
+	if servants then
+		result, except = self.referrer:islocal(reference, servants.accesspoint)
+		if result then                                                              --[[VERBOSE]] verbose:proxies("local object with key '",result,"' restored")
+			result = servants:retrieve(result)
+		end
+	end
+	if not result then                                                            --[[VERBOSE]] verbose:proxies("new proxy created for reference", reference)
+		result, except = self:newproxy(reference, ...)
+	end                                                                           --[[VERBOSE]] verbose:proxies(false)
+	return result, except
+end
+
+function newproxy(self, reference)                                              --[[VERBOSE]] verbose:proxies("new proxy to ",reference)
+	return self.class{
+		__manager = self,
+		__reference = reference,
+	}
+end
+
+function excepthandler(self, handler)                                           --[[VERBOSE]] verbose:proxies("setting exception handler for proxies")
+	self.defaulthandler = handler
+	return true
+end

data/vendor/lua/lib/lua/oil/kernel/base/Proxies/asynchronous.lua

@@ -0,0 +1,56 @@
+local oo    = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+local utils = require "oil.kernel.base.Proxies.utils"
+
+local assertresults = utils.assertresults
+local unpackrequest = utils.unpackrequest
+
+--------------------------------------------------------------------------------
+
+local Request = oo.class()
+
+function Request:ready()                                                        --[[VERBOSE]] verbose:proxies("check reply availability")
+	local proxy = self.proxy
+	assertresults(proxy, self.member,
+	              proxy.__manager.requester:getreply(self, true))
+	return self.success ~= nil
+end
+
+function Request:results()                                                      --[[VERBOSE]] verbose:proxies(true, "get reply results")
+	local success, except = self.proxy.__manager.requester:getreply(self)
+	if success then                                                               --[[VERBOSE]] verbose:proxies(false, "got results successfully")
+		return unpackrequest(self)
+	end                                                                           --[[VERBOSE]] verbose:proxies(false, "got errors while reading reply")
+	return success, except
+end
+
+function Request:evaluate()                                                     --[[VERBOSE]] verbose:proxies("get deferred results of ",self.member)
+	return assertresults(self.proxy, self.member, self:results())
+end
+
+--------------------------------------------------------------------------------
+
+local Failed = oo.class({}, Request)
+
+function Failed:ready()
+	return true
+end
+
+function Failed:results()
+	return false, self[1]
+end
+
+--------------------------------------------------------------------------------
+
+return function(invoker, operation)
+	return function(self, ...)
+		local request, except = invoker(self, ...)
+		if request then
+			request = Request(request)
+		else
+			request = Failed{ except }
+		end
+		request.proxy = self
+		request.member = operation
+		return request
+	end
+end

data/vendor/lua/lib/lua/oil/kernel/base/Proxies/protected.lua

@@ -0,0 +1,17 @@
+local utils = require "oil.kernel.base.Proxies.utils"
+
+local unpackrequest = utils.unpackrequest
+
+return function(invoker)
+	return function(self, ...)
+		local success, except = invoker(self, ...)
+		if success then
+			local request = success
+			success, except = self.__manager.requester:getreply(request)
+			if success then
+				return unpackrequest(request)
+			end
+		end
+		return success, except
+	end
+end

data/vendor/lua/lib/lua/oil/kernel/base/Proxies/synchronous.lua

@@ -0,0 +1,17 @@
+local utils = require "oil.kernel.base.Proxies.utils"
+
+local assertresults = utils.assertresults
+local unpackrequest = utils.unpackrequest
+local callhandler   = utils.callhandler
+
+return function(invoker, operation)
+	return function(self, ...)
+		local request, except = invoker(self, ...)
+		if request then
+			assertresults(self, operation, self.__manager.requester:getreply(request))
+			return assertresults(self, operation, unpackrequest(request))
+		else
+			return callhandler(self, except, operation)
+		end
+	end
+end

data/vendor/lua/lib/lua/oil/kernel/base/Proxies/utils.lua

@@ -0,0 +1,29 @@
+local error        = error
+local getmetatable = getmetatable
+local rawget       = rawget
+local unpack       = unpack                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.base.Proxies.utils"
+
+function proxytostring(self)
+	return self.__manager.referrer:encode(self.__reference)
+end
+
+function unpackrequest(request)
+	return request.success, unpack(request, 1, request.n)
+end
+
+function callhandler(self, ...)
+	local handler = rawget(self, "__exceptions") or
+	                rawget(getmetatable(self), "__exceptions") or
+	                self.__manager.proxies.defaulthandler or
+	                error((...))
+	return handler(self, ...)
+end
+
+function assertresults(self, operation, success, except, ...)
+	if not success then
+		return callhandler(self, except, operation)
+	end
+	return except, ...
+end

data/vendor/lua/lib/lua/oil/kernel/base/Receiver.lua

@@ -0,0 +1,110 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Request Acceptor                                                  --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- acceptor:Facet
+-- 	configs:table, [except:table] setupaccess([configs:table])
+-- 	success:boolean, [except:table] hasrequest(configs:table)
+-- 	success:boolean, [except:table] acceptone(configs:table)
+-- 	success:boolean, [except:table] acceptall(configs:table)
+-- 	success:boolean, [except:table] halt(configs:table)
+-- 
+-- listener:Receptacle
+-- 	configs:table default([configs:table])
+-- 	channel:object, [except:table] getchannel(configs:table)
+-- 	success:boolean, [except:table] freeaccess(configs:table)
+-- 	success:boolean, [except:table] freechannel(channel:object)
+-- 	request:table, [except:table] = getrequest(channel:object, [probe:boolean])
+-- 	success:booelan, [except:table] = sendreply(request:table, success:booelan, results...)
+-- 
+-- dispatcher:Receptacle
+-- 	success:boolean, [except:table]|results... dispatch(objectkey:string, operation:string|function, params...)
+--------------------------------------------------------------------------------
+
+
+local oo        = require "oil.oo"
+local Exception = require "oil.Exception"                                       --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.base.Receiver", oo.class)
+
+function processrequest(self, request)
+	self.dispatcher:dispatch(request)
+	return self.listener:sendreply(request)
+end
+
+--------------------------------------------------------------------------------
+
+function initialize(self, config)
+	local result, except = self.listener:setupaccess(config)
+	if result then
+		self.accesspoint = result
+	end
+	return result, except
+end
+
+function hasrequest(self)
+	return self.listener:getchannel(self.accesspoint, true)
+end
+
+function acceptone(self)                                                        --[[VERBOSE]] verbose:acceptor(true, "accept one request from channel ",self.accesspoint)
+	local result, except
+	local listener = self.listener
+	result, except = listener:getchannel(self.accesspoint)
+	if result then
+		local channel = result
+		result, except = listener:getrequest(channel)
+		if (result and result ~= true)
+		or (not result and except.reason ~= "closed") then
+			listener:putchannel(channel)
+		end
+		if result and result ~= true then                                           --[[VERBOSE]] verbose:acceptor(true, "dispatching request from accepted channel")
+			result, except = self:processrequest(result)                              --[[VERBOSE]] verbose:acceptor(false)
+		end
+	end                                                                           --[[VERBOSE]] verbose:acceptor(false)
+	return result, except
+end
+
+function acceptall(self)
+	local listener = self.listener
+	local accesspoint = self.accesspoint                                          --[[VERBOSE]] verbose:acceptor(true, "accept all requests from channel ",accesspoint)
+	local result, except
+	self[accesspoint] = true
+	repeat
+		result, except = listener:getchannel(accesspoint)
+		if result then
+			local channel = result
+			result, except = listener:getrequest(channel)
+			if (result and result ~= true)
+			or (not result and except.reason ~= "closed") then
+				listener:putchannel(channel)
+			end
+			if result and result ~= true then                                         --[[VERBOSE]] verbose:acceptor "dispatching request from accepted channel"
+				result, except = self:processrequest(result)
+			end
+		end
+	until not result or not self[accesspoint]                                     --[[VERBOSE]] verbose:acceptor(false)
+	return result, except
+end
+
+function halt(self)                                                             --[[VERBOSE]] verbose:acceptor "halt acceptor"
+	local accesspoint = self.accesspoint
+	if self[accesspoint] then
+		self[accesspoint] = nil
+		return self.listener:freeaccess(accesspoint)
+	else
+		return nil, Exception{
+			reason = "halt",
+			message = "channels not being accepted",
+		}
+	end
+end

data/vendor/lua/lib/lua/oil/kernel/base/Servants.lua

@@ -0,0 +1,207 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Server-Side Broker                                                --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- broker:Facet
+-- 	servant:object register(impl:object, [objectkey:string])
+-- 	impl:object remove(servant:object|impl:object|objectkey:string)
+-- 	impl:object retrieve(objectkey:string)
+-- 	reference:string tostring(servant:object)
+-- 
+-- referrer:Receptacle
+-- 	reference:table newreference(objectkey:string, accesspointinfo:table...)
+-- 	stringfiedref:string encode(reference:table)
+--------------------------------------------------------------------------------
+
+local getmetatable = getmetatable
+local rawget       = rawget
+local rawset       = rawset
+local setmetatable = setmetatable
+local luatostring  = tostring
+local type         = type
+
+local table = require "loop.table"
+local ObjectCache = require "loop.collection.ObjectCache"
+
+local oo = require "oil.oo"
+local Exception = require "oil.Exception"                                       --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.base.Servants", oo.class)
+
+prefix = "_"
+
+--------------------------------------------------------------------------------
+-- Servant object proxy
+
+local function deactivate(self)
+	return self.__manager:removeentry(self.__key)
+end
+
+local function wrappertostring(self)
+	return self.__manager.referrer:encode(self.__reference)
+end
+
+local function wrapperindexer(self, key)
+	local value = self.__newindex[key]
+	if type(value) == "function"
+		then return self.__methods[value]
+		else return value
+	end
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function __init(self, ...)
+	self = oo.rawnew(self, ...)
+	self.map = self.map or {}
+	return self
+end
+
+function addentry(self, key, entry)
+	local result, except = self.map[key]
+	if result then
+		if result == entry then
+			result = true
+		else
+			result, except = nil, Exception{
+				reason = "usedkey",
+				message = "object key already in use",
+				key = key,
+			}
+		end
+	else                                                                          --[[VERBOSE]] verbose:servants("object ",entry," registered with key ",key)
+		self.map[key] = entry
+		result = true
+	end
+	return result, except
+end
+
+function removeentry(self, key)
+	local map = self.map
+	local entry = map[key]
+	if entry ~= nil then                                                          --[[VERBOSE]] verbose:servants("object ",entry," with key ",key," removed")
+		map[key] = nil
+		return entry
+	end
+	return nil, Exception{
+		reason = "usedkey",
+		message = "unknown object key",
+		key = key,
+	}
+end
+
+function hashof(self, object)
+	local meta = getmetatable(object)
+	local backup
+	if meta then
+		backup = rawget(meta, "__tostring")
+		if backup ~= nil then rawset(meta, "__tostring", nil) end
+	end
+	local hash = luatostring(object)
+	if meta then
+		if backup ~= nil then rawset(meta, "__tostring", backup) end
+	end
+	return hash:match("%l+: (%w+)") or hash
+end
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function setaccessinfo(self, ...)
+	local result, except = true
+	local accessinfo = self.accessinfo
+	if not accessinfo then
+		self.accessinfo = {...}
+	else
+		result, except = nil, Exception{
+			reason = "configuration",
+			message = "attempt to set access info twice",
+			accessinfo = accessinfo,
+		}
+	end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function resolvekey(self, object)
+	local key = nil
+	local meta = getmetatable(object)
+	if type(object) == "table" or (meta ~= nil and meta.__index) then
+		key = object.__objkey
+	end
+	if key == nil and meta ~= nil then
+		 key = meta.__objkey
+	end
+	if key == nil then
+		key = self.prefix..self:hashof(object)
+	end
+	return key
+end
+
+function register(self, object, key, ...)
+	if key == nil then
+		key = self:resolvekey(object)
+	end
+	local result, except = self:addentry(key, object, ...)
+	if result then
+		result, except = self.referrer:newreference(self.accesspoint, key, ...)
+		if result then
+			result = {
+				_deactivate = deactivate, -- TODO[maia]: DEPRECATED!
+				__deactivate = deactivate,
+				__manager = self,
+				__key = key,
+				__tostring = wrappertostring,
+				__index = wrapperindexer,
+				__newindex = object,
+				__reference = result,
+				__methods = ObjectCache{
+					retrieve = function(_, method)
+						return function(_, ...)
+							return method(object, ...)
+						end
+					end
+				}
+			}
+			setmetatable(result, result)
+		else
+			self:removeentry(key)
+		end
+	end
+	return result, except
+end
+
+function remove(self, key)
+	local keytype = type(key)
+	if keytype ~= "string" then
+		local object = key
+		if keytype == "table" then
+			key = rawget(object, "__key") -- is it a servant?
+			keytype = type(key)
+		end
+		if keytype ~= "string" then
+			local except
+			key, except = self:resolvekey(object)
+			if not key then                                                           --[[VERBOSE]] verbose:servants("unbale to identify key of object ",entry)
+				return nil, except
+			end
+		end
+	end
+	return self:removeentry(key)
+end
+
+function retrieve(self, key)
+	return self.map[key]
+end