rufus-lua-win 5.1.5

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

@@ -0,0 +1,153 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- 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)
+--
+-- indexer:Facet
+-- 	interface:table typeof(reference:table)
+-- 	member:table, [islocal:function], [cached:boolean] valueof(interface:table, name:string)
+--
+-- invoker:Receptacle
+-- 	[results:object], [except:table] invoke(reference, operation, args...)
+--------------------------------------------------------------------------------
+
+local rawset = rawset
+
+local tabop       = require "loop.table"                                        --[[VERBOSE]] local select = select
+local ObjectCache = require "loop.collection.ObjectCache"                       --[[VERBOSE]] local type   = type
+
+local oo        = require "oil.oo"
+local Exception = require "oil.Exception"
+local Proxies   = require "oil.kernel.base.Proxies"                             --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.typed.Proxies"
+
+oo.class(_M, Proxies)
+
+--------------------------------------------------------------------------------
+
+local function newclass(methodmaker)
+	return oo.class{
+		__call = oo.rawnew,
+		__index = function(cache, field)                                            --[[VERBOSE]] verbose:proxies("first attempt to invoke operation ",field)
+			local manager = cache.__manager
+			local operation = manager.indexer:valueof(cache.__type, field)
+			if operation then
+				local function invoker(self, ...)                                       --[[VERBOSE]] verbose:proxies("call to ",operation, ...)
+					return manager.requester:newrequest(self.__reference, operation, ...)
+				end
+				invoker = methodmaker(invoker, operation)                               --[[VERBOSE]] verbose:proxies("operation named ",field," was created")
+				cache[field] = invoker                                                  --[[VERBOSE]]
+				return invoker                                                          --[[VERBOSE]] else verbose:proxies("operation named ",field," not found")
+			end
+		end
+	}
+end
+
+--------------------------------------------------------------------------------
+
+function proxynarrow(self, type)
+	return self.__manager.proxies:newproxy(self.__reference, type)
+end
+
+function __init(self, ...)
+	self = oo.rawnew(self, ...)
+	self.class = self.class or newclass(self.invoker)
+	self.classes = ObjectCache{
+		retrieve = function(_, type)
+			local class = self.class()
+			local updater = {}
+			function updater.notify()
+				tabop.clear(class)
+				class.__manager = self
+				class.__type = type
+				class.__tostring = proxytostring
+				class.__narrow = proxynarrow
+				class._narrow = proxynarrow -- TODO:[maia] DEPRECATED!
+				oo.initclass(class)
+			end
+			updater:notify()
+			if type.observer then
+				rawset(type.observer, class, updater)
+			end
+			return class
+		end
+	}
+	return self
+end
+
+--------------------------------------------------------------------------------
+
+function newproxy(self, reference, type)                                        --[[VERBOSE]] verbose:proxies(true, "new proxy to ",reference," with type ",type)
+	local result, except
+	if not type then                                                              --[[VERBOSE]] verbose:proxies(true, "interface of proxy not provided, attempt to discover it")
+		type, except = self.referrer:typeof(reference)                              --[[VERBOSE]] verbose:proxies(false, "interface of proxy",(type and " " or " not "),"found")
+	end
+	if type then
+		type, except = self.types:resolve(type)
+		if type then
+			result = self.classes[type]{ __reference = reference }
+		end
+	end                                                                           --[[VERBOSE]] verbose:proxies(false)
+	return result, except
+end
+
+function excepthandler(self, handler, type)                                     --[[VERBOSE]] verbose:proxies("setting exception handler for proxies of ",type)
+	local result, except = true
+	if type == nil then
+		result, except = Proxies.excepthandler(self, handler)
+	else
+		result, except = self.types:resolve(type)
+		if result then
+			type = result
+			local class = self.classes[type]
+			class.__exceptions = handler
+			result, except = class, nil
+		end
+	end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+--[[VERBOSE]] function verbose.custom:proxies(...)
+--[[VERBOSE]] 	local params
+--[[VERBOSE]] 	for i = 1, select("#", ...) do
+--[[VERBOSE]] 		local value = select(i, ...)
+--[[VERBOSE]] 		local type = type(value)
+--[[VERBOSE]] 		if 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]] 			end
+--[[VERBOSE]] 		elseif not params and type == "table" and
+--[[VERBOSE]] 		       value._type == "operation" then
+--[[VERBOSE]] 			params = "("
+--[[VERBOSE]] 			self.viewer.output:write(value.name)
+--[[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/typed/Servants.lua

@@ -0,0 +1,137 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- 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)
+-- 
+-- types:Receptacle
+-- 	type:table resolve(type:string)
+--------------------------------------------------------------------------------
+
+local getmetatable = getmetatable
+local rawget       = rawget
+local type         = type
+
+local table = require "loop.table"
+
+local oo       = require "oil.oo"
+local Servants = require "oil.kernel.base.Servants"                             --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.typed.Servants"
+
+oo.class(_M, Servants)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function addentry(self, key, impl, type)
+	local entry = self.map[key]
+	if entry == nil
+	or entry.object ~= impl
+	or entry.type ~= type
+	then
+		return Servants.addentry(self, key, { object = impl, type = type })
+	end
+	return true
+end
+
+function removeentry(self, key)
+	local result, except = Servants.removeentry(self, key)
+	if result then result, except = result.object, result.type end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function resolvetype(self, object)
+	local objtype = nil
+	local meta = getmetatable(object)
+	if type(object) == "table" or (meta ~= nil and meta.__index) then
+		objtype = object.__type
+	end
+	if objtype == nil and meta ~= nil then
+		 objtype = meta.__type
+	end
+	return self.types:resolve(objtype)
+end
+
+function resolvekey(self, object, objtype)
+	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 and objtype ~= nil then
+		key = self.prefix..self:hashof(object)..self:hashof(objtype)
+	end
+	return key
+end
+
+function register(self, object, objkey, objtype)
+	local except
+	if objtype == nil then
+		objtype, except = self:resolvetype(object)
+	else
+		objtype, except = self.types:resolve(objtype)
+	end
+	if not objtype then
+		return nil, except
+	end
+	if objkey == nil then
+		objkey = self:resolvekey(object, objtype)
+	end
+	return Servants.register(self, object, objkey, objtype)
+end
+
+function remove(self, objkey, objtype)
+	local keytype = type(objkey)
+	if keytype ~= "string" then
+		local object = objkey
+		if keytype == "table" then
+			objkey = rawget(object, "__key")
+			keytype = type(objkey)
+		end
+		if keytype ~= "string" then
+			objkey = self:resolvekey(object)
+			if objkey == nil then
+				local except
+				if objtype == nil then
+					objtype, except = self:resolvetype(object)
+				end
+				if not objtype then                                                     --[[VERBOSE]] verbose:servants("unable to identify type of object ",object)
+					return nil, except
+				end
+				objkey = self.prefix..self:hashof(object)..self:hashof(objtype)
+			end
+		end
+	end
+	return self:removeentry(objkey)
+end
+
+function retrieve(self, key)
+	local result, except = Servants.retrieve(self, key)
+	if result then result, except = result.object, result.type end
+	return result, except
+end

data/vendor/lua/lib/lua/oil/ludo/Codec.lua

@@ -0,0 +1,66 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Client-side CORBA GIOP Protocol specific to IIOP                  --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- channels:Facet
+-- 	channel:object retieve(configs:table)
+-- 	channel:object select(channel|configs...)
+-- 	configs:table default(configs:table)
+-- 
+-- sockets:Receptacle
+-- 	socket:object tcp()
+-- 	input:table, output:table select([input:table], [output:table], [timeout:number])
+--------------------------------------------------------------------------------
+
+local pairs   = pairs
+local require = require
+
+local table        = require "loop.table"
+local StringStream = require "loop.serial.StringStream"
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.ludo.Codec", oo.class)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+local WeakKey    = oo.class{ __mode = "k" }
+local WeakValues = oo.class{ __mode = "v" }
+
+function __init(self, ...)
+	self = oo.rawnew(self, ...)
+	self.names = WeakKey(self.names)
+	self.values = WeakValues(self.values)
+	return self
+end
+
+function localresources(self, resources)
+	local names = self.names
+	local values = self.values
+	for name, resource in pairs(resources) do
+		names[resource] = name
+		values[name] = resource
+	end
+end
+
+function encoder(self)
+	return StringStream(table.copy(self.names))
+end
+
+function decoder(self, stream)
+	return StringStream{
+		environment = table.copy(self.values),
+		data = stream,
+	}
+end

data/vendor/lua/lib/lua/oil/ludo/CodecByRef.lua

@@ -0,0 +1,103 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Client-side CORBA GIOP Protocol specific to IIOP                  --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- channels:Facet
+-- 	channel:object retieve(configs:table)
+-- 	channel:object select(channel|configs...)
+-- 	configs:table default(configs:table)
+-- 
+-- sockets:Receptacle
+-- 	socket:object tcp()
+-- 	input:table, output:table select([input:table], [output:table], [timeout:number])
+--------------------------------------------------------------------------------
+
+local getmetatable = getmetatable
+local pairs = pairs
+local tonumber = tonumber
+local tostring = tostring
+local rawget = rawget
+local rawset = rawset
+
+local table        = require "loop.table"
+local StringStream = require "loop.serial.StringStream"
+
+local oo    = require "oil.oo"
+local Codec = require "oil.ludo.Codec"                                             --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.ludo.CodecByRef"
+
+oo.class(_M, Codec)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+-- TODO:[maia] copied from loop.serial.Serializer. Make it a member function
+local function getidfor(value)
+	local meta = getmetatable(value)
+	local backup
+	if meta then
+		backup = rawget(meta, "__tostring")
+		if backup ~= nil then rawset(meta, "__tostring", nil) end
+	end
+	local id = tostring(value):match("%l+: (%w+)")
+	if meta then
+		if backup ~= nil then rawset(meta, "__tostring", backup) end
+	end
+	return tonumber(id, 16) or id
+end
+
+local function serialproxy(self, value, id)                                     --[[VERBOSE]] verbose:marshal("marshalling proxy for value ",value)
+	self[value] = self.namespace..":value("..id..")"
+	self:write(self.namespace,":value(",id,",'table',")
+	self:write("proxies:resolve(")
+	local reference = self.servants:register(value).__reference
+	StringStream.table(self, reference, getidfor(reference))
+	self:write("))")
+end
+
+local function serialtable(self, value, id)                                     --[[VERBOSE]] verbose:marshal(true, "marshalling of table ",value)
+	local reference = rawget(value, "__reference")
+	if reference then                                                             --[[VERBOSE]] verbose:marshal "table is a proxy"
+		self[value] = self.namespace..":value("..id..")"
+		self:write(self.namespace,":value(",id,",'table',")
+		self:write("proxies:resolve(")
+		StringStream.table(self, reference, getidfor(reference))
+		self:write("))")
+	else
+		local meta = getmetatable(value)
+		if meta and meta.__marshalcopy then                                         --[[VERBOSE]] verbose:marshal "table by copy"
+			StringStream.table(self, value, id)
+		else                                                                        --[[VERBOSE]] verbose:marshal "table by reference"
+			serialproxy(self, value, id)
+		end                                                                         --[[VERBOSE]] verbose:marshal(false)
+	end
+end
+
+local LuDOStream = oo.class({
+	table        = serialtable,
+	thread       = serialproxy,
+	userdata     = serialproxy,
+	["function"] = serialproxy,
+}, StringStream)
+
+function encoder(self)
+	return LuDOStream(table.copy(self.names, {servants = self.servants}))
+end
+
+function decoder(self, stream)
+	return StringStream{
+		environment = table.copy(self.values, {proxies = self.proxies}),
+		data = stream,
+	}
+end