A simple communication abstraction for CC

Dentatsu.lua

local loading = {}
local oldRequire, preload, loaded = require, {}, { startup = loading }

local function require(name)
	local result = loaded[name]

	if result ~= nil then
		if result == loading then
			error("loop or previous error loading module '" .. name .. "'", 2)
		end

		return result
	end

	loaded[name] = loading
	local contents = preload[name]
	if contents then
		result = contents(name)
	elseif oldRequire then
		result = oldRequire(name)
	else
		error("cannot load '" .. name .. "'", 2)
	end

	if result == nil then result = true end
	loaded[name] = result
	return result
end
preload["lib.base64"] = function(...)
local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

-- encoding
local function enc(data)
    return ((data:gsub('.', function(x)
        local r,b='',x:byte()
        for i=8,1,-1 do r=r..(b%2^i-b%2^(i-1)>0 and '1' or '0') end
        return r;
    end)..'0000'):gsub('%d%d%d?%d?%d?%d?', function(x)
        if (#x < 6) then return '' end
        local c=0
        for i=1,6 do c=c+(x:sub(i,i)=='1' and 2^(6-i) or 0) end
        return b:sub(c+1,c+1)
    end)..({ '', '==', '=' })[#data%3+1])
end

-- decoding
local function dec(data)
    data = string.gsub(data, '[^'..b..'=]', '')
    return (data:gsub('.', function(x)
        if (x == '=') then return '' end
        local r,f='',(b:find(x)-1)
        for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
        return r;
    end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
        if (#x ~= 8) then return '' end
        local c=0
        for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
        return string.char(c)
    end))
end

return {
  encode = enc,
  decode = dec
}
end
preload["lib.30log"] = function(...)
local next, assert, pairs, type, tostring, setmetatable, baseMt, _instances, _classes, _class = next, assert, pairs, type, tostring, setmetatable, {}, setmetatable({},{__mode = 'k'}), setmetatable({},{__mode = 'k'})
local function assert_call_from_class(class, method) assert(_classes[class], ('Wrong method call. Expected class:%s.'):format(method)) end; local function assert_call_from_instance(instance, method) assert(_instances[instance], ('Wrong method call. Expected instance:%s.'):format(method)) end
local function bind(f, v) return function(...) return f(v, ...) end end
local default_filter = function() return true end
local function deep_copy(t, dest, aType) t = t or {}; local r = dest or {}; for k,v in pairs(t) do if aType ~= nil and type(v) == aType then r[k] = (type(v) == 'table') and ((_classes[v] or _instances[v]) and v or deep_copy(v)) or v elseif aType == nil then r[k] = (type(v) == 'table') and k~= '__index' and ((_classes[v] or _instances[v]) and v or deep_copy(v)) or v end; end return r end
local function instantiate(call_init,self,...) assert_call_from_class(self, 'new(...) or class(...)'); local instance = {class = self}; _instances[instance] = tostring(instance); deep_copy(self, instance, 'table')
	instance.__index, instance.__subclasses, instance.__instances, instance.mixins = nil, nil, nil, nil; setmetatable(instance,self); if call_init and self.init then if type(self.init) == 'table' then deep_copy(self.init, instance) else self.init(instance, ...) end end; return instance
end
local function extend(self, name, extra_params)
	assert_call_from_class(self, 'extend(...)'); local heir = {}; _classes[heir] = tostring(heir); self.__subclasses[heir] = true; deep_copy(extra_params, deep_copy(self, heir))
	heir.name, heir.__index, heir.super, heir.mixins = extra_params and extra_params.name or name, heir, self, {}; return setmetatable(heir,self)
end
baseMt = { __call = function (self,...) return self:new(...) end, __tostring = function(self,...)
	if _instances[self] then return ("instance of '%s' (%s)"):format(rawget(self.class,'name') or '?', _instances[self]) end; return _classes[self] and ("class '%s' (%s)"):format(rawget(self,'name') or '?', _classes[self]) or self end
}; _classes[baseMt] = tostring(baseMt); setmetatable(baseMt, {__tostring = baseMt.__tostring})
local class = {isClass = function(t) return not not _classes[t] end, isInstance = function(t) return not not _instances[t] end}
_class = function(name, attr) local c = deep_copy(attr); _classes[c] = tostring(c)
	c.name, c.__tostring, c.__call, c.new, c.create, c.extend, c.__index, c.mixins, c.__instances, c.__subclasses = name or c.name, baseMt.__tostring, baseMt.__call, bind(instantiate, true), bind(instantiate, false), extend, c, setmetatable({},{__mode = 'k'}), setmetatable({},{__mode = 'k'}), setmetatable({},{__mode = 'k'})
	c.subclasses = function(self, filter, ...) assert_call_from_class(self, 'subclasses(class)'); filter = filter or default_filter; local subclasses = {}; for class in pairs(_classes) do if class ~= baseMt and class:subclassOf(self) and filter(class,...) then subclasses[#subclasses + 1] = class end end; return subclasses end
	c.instances = function(self, filter, ...) assert_call_from_class(self, 'instances(class)'); filter = filter or default_filter; local instances = {}; for instance in pairs(_instances) do if instance:instanceOf(self) and filter(instance, ...) then instances[#instances + 1] = instance end end; return instances end
	c.subclassOf = function(self, superclass) assert_call_from_class(self, 'subclassOf(superclass)'); assert(class.isClass(superclass), 'Wrong argument given to method "subclassOf()". Expected a class.'); local super = self.super; while super do if super == superclass then return true end; super = super.super end; return false end
	c.classOf = function(self, subclass) assert_call_from_class(self, 'classOf(subclass)'); assert(class.isClass(subclass), 'Wrong argument given to method "classOf()". Expected a class.'); return subclass:subclassOf(self) end
	c.instanceOf = function(self, fromclass) assert_call_from_instance(self, 'instanceOf(class)'); assert(class.isClass(fromclass), 'Wrong argument given to method "instanceOf()". Expected a class.'); return ((self.class == fromclass) or (self.class:subclassOf(fromclass))) end
	c.cast = function(self, toclass) assert_call_from_instance(self, 'instanceOf(class)'); assert(class.isClass(toclass), 'Wrong argument given to method "cast()". Expected a class.'); setmetatable(self, toclass); self.class = toclass; return self end
	c.with = function(self,...) assert_call_from_class(self, 'with(mixin)'); for _, mixin in ipairs({...}) do assert(self.mixins[mixin] ~= true, ('Attempted to include a mixin which was already included in %s'):format(tostring(self))); self.mixins[mixin] = true; deep_copy(mixin, self, 'function') end return self end
	c.includes = function(self, mixin) assert_call_from_class(self,'includes(mixin)'); return not not (self.mixins[mixin] or (self.super and self.super:includes(mixin))) end
	c.without = function(self, ...) assert_call_from_class(self, 'without(mixin)'); for _, mixin in ipairs({...}) do
		assert(self.mixins[mixin] == true, ('Attempted to remove a mixin which is not included in %s'):format(tostring(self))); local classes = self:subclasses(); classes[#classes + 1] = self
		for _, class in ipairs(classes) do for method_name, method in pairs(mixin) do if type(method) == 'function' then class[method_name] = nil end end end; self.mixins[mixin] = nil end; return self end; return setmetatable(c, baseMt) end
class._DESCRIPTION = '30 lines library for object orientation in Lua'; class._VERSION = '30log v1.2.0'; class._URL = 'http://github.com/Yonaba/30log'; class._LICENSE = 'MIT LICENSE <http://www.opensource.org/licenses/mit-license.php>'
return setmetatable(class,{__call = function(_,...) return _class(...) end })
end
preload["receiver.Receiver"] = function(...)
local class = require "lib.30log"
local Receiver = class "Receiver"

function Receiver:init()
end

function Receiver:receive()
  return nil
end

return Receiver
end
preload["receiver.DummyReceiver"] = function(...)
local class = require "lib.30log"
local Receiver = require "receiver.Receiver"
local DummyReceiver = Receiver:extend "DummyReceiver"

local Packet = require "packet.Packet"
local Target = require "packet.Target"

function DummyReceiver:receive()
  sleep(5)
  local target = Target(1,true)
  local source = Target(2,false)
  local packet = Packet("VEhJUyBJUyBBIFBBQ0tFVA==", target, source)
  return packet
end

return DummyReceiver
end
preload["receiver.RednetReceiver"] = function(...)
local class = require "lib.30log"
local Receiver = require "receiver.Receiver"
local RednetReceiver = Receiver:extend "RednetReceiver"

local Packet = require "packet.Packet"
local Target = require "packet.Target"

function RednetReceiver:receive()
  local evt = {os.pullEvent()}
  while evt[1] ~= "rednet_message" do
    evt = {os.pullEvent()}
  end
  local target = Target(os.getComputerID(), true)
  local source = Target(evt[2], false)
  local packet = Packet(evt[3], target, source)
  return packet
end

return RednetReceiver
end
preload["packet.Target"] = function(...)
local class = require "lib.30log"
local Target = class "Target"

function Target:init(channel, isSelf)
  self._channel = channel
  self._isSelf = isSelf and isSelf or false
end

function Target:getTarget()
  return self._channel
end

function Target:isSelf()
  return self._isSelf
end

return Target
end
preload["packet.Packet"] = function(...)
local class = require "lib.30log"
local Packet = class "Packet"

function Packet:init(content, target, source)
  self._content = content
  self._target = target
  self._source = source
end

function Packet:getContent()
  return self._content
end

function Packet:getTarget()
  return self._target
end

function Packet:getSource()
  return self._source
end

function Packet:setContent(content)
  self._content = content
end

function Packet:setTarget(target)
  self._target = target
end

function Packet:setSource(source)
  self._source = source
end

return Packet
end
preload["processor.Base64Processor"] = function(...)
local base64 = require "lib.base64"
local class = require "lib.30log"
local Processor = require "processor.Processor"
local Base64Processor = Processor:extend("Base64Processor")

function Base64Processor:process(packet)
  if(packet:getTarget():isSelf()) then
    packet:setContent(base64.decode(packet:getContent()))
  else
    packet:setContent(base64.encode(packet:getContent()))
  end
  return packet
end

return Base64Processor
end
preload["processor.ProcessorChain"] = function(...)
local class = require "lib.30log"

local ProcessorChain = class "ProcessorChain"

function ProcessorChain:init(list)
  self._processors = list
end

function ProcessorChain:process(pac)
  for k,v in pairs(self._processors) do
    pac = v:process(pac)
  end
  return pac
end

return ProcessorChain
end
preload["processor.Processor"] = function(...)
local class = require "lib.30log"

local Processor = class "Processor"

function Processor:init()
end

function Processor:process(v)
  return v
end

return Processor
end
preload["transmitter.Transmitter"] = function(...)
local class = require "lib.30log"
local Transmitter = class "Transmitter"

function Transmitter:init()
end

function Transmitter:transmit(packet)
end

return Transmitter
end
preload["transmitter.RednetTransmitter"] = function(...)
local class = require "lib.30log"
local Receiver = require "receiver.Receiver"
local RednetTransmitter = Receiver:extend "RednetTransmitter"

function RednetTransmitter:transmit(packet)
  rednet.send(packet:getTarget():getTarget(), packet:getContent())
end

return RednetTransmitter
end
preload["transmitter.DummyTransmitter"] = function(...)
local class = require "lib.30log"
local Transmitter = require "transmitter.Transmitter"
local DummyTransmitter = Transmitter:extend "DummyTransmitter"

function DummyTransmitter:transmit(packet)
  print "TRANSMITTED"
  return true
end

return DummyTransmitter
end
preload["wrapper.Wrapper"] = function(...)
local class = require "lib.30log"
local ProcessorChain = require "processor.ProcessorChain"

local Packet = require "packet.Packet"

local Wrapper = class "Wrapper"

local function dcopy(t)
  if(type(t) ~= "table") then return t end
  local tt = {}
  for k,v in pairs(t) do tt[dcopy(k)] = dcopy(v) end
  tt = setmetatable(tt, dcopy(getmetatable(t)))
  return tt
end

function Wrapper:init(receiver, transmitter, inProcessors, outProcessors)
  self._receiver = receiver
  self._transmitter = transmitter
  self._inProcessors = ProcessorChain(inProcessors)
  self._outProcessors = ProcessorChain(outProcessors)
  self._packetQueue = {}
  self._receiveQueue = {}
  self._sendQueue = {}
  self._handlers = {}
end

function Wrapper:addHandler(func)
  table.insert(self._handlers, func)
end

function Wrapper:send(packet)
  table.insert(self._packetQueue, packet)
end

function Wrapper:run()
  parallel.waitForAny(
    --# Function handling the receiving part
    function()
      while true do
        local msg = self._receiver:receive()
        if(msg ~= nil) then
          table.insert(self._packetQueue, msg)
        end
        sleep(0)
      end
    end,
    --# Function handling the "processor" part
    function()
      while true do
        local toRemove = {}
        for k,v in pairs(self._packetQueue) do
          if(v:getTarget():isSelf()) then
            v = self._inProcessors:process(v)
            table.insert(self._receiveQueue, v)
          else
            v = self._outProcessors:process(v)
            table.insert(self._sendQueue, v)
          end
        end
        self._packetQueue = {}
        sleep(0)
      end
    end,
    --# function which handles the sending part
    function()
      while true do
        if(#self._sendQueue > 0) then
          for k,v in pairs(self._sendQueue) do
            self._transmitter:transmit(v)
          end
          self._sendQueue = {}
        end
        sleep(0)
      end
    end,
    --# function which delivers the received
    --# and processed messages to the handlers
    function()
      while true do
        if(#self._receiveQueue > 0) then
          for k,v in pairs(self._receiveQueue) do
            for i,j in pairs(self._handlers) do
              j(v, function(content)
                self:send(
                  Packet(
                    content,
                    v:getSource(),
                    v:getTarget()
                  )
                )
              end)
            end
          end
          self._receiveQueue = {}
        end
        sleep(0)
      end
    end
  )
end

return Wrapper
end
preload["dentatsu.dentatsu"] = function(...)
local d = {}

d.receiver = {}
d.transmitter = {}
d.processor = {}
d.wrapper = {}

d.receiver.Receiver = require "receiver.Receiver"
d.receiver.Dummy = require "receiver.DummyReceiver"
d.receiver.Rednet = require "receiver.RednetReceiver"

d.transmitter.Transmitter = require "transmitter.Transmitter"
d.transmitter.Dummy = require "transmitter.DummyTransmitter"
d.transmitter.Rednet = require "transmitter.RednetTransmitter"

d.processor.Processor = require "processor.Processor"
d.processor.Base64 = require "processor.Base64Processor"

d.wrapper.Wrapper = require "wrapper.Wrapper"

return d
end
return preload["dentatsu.dentatsu"](...)

Dentatsu.min.lua

local e={}local t,a,o=require,{},{startup=e}
local function i(n)local s=o[n]
if s~=nil then if s==e then
error("loop or previous error loading module '"..n..
"'",2)end;return s end;o[n]=e;local h=a[n]if h then s=h(n)elseif t then s=t(n)else
error("cannot load '"..n.."'",2)end;if s==nil then s=true end;o[n]=s;return s end
a["lib.base64"]=function(...)
local n='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
local function s(r)
return
(
(
r:gsub('.',function(d)local l,n='',d:byte()
for u=8,1,-1 do l=l.. (
n%2^u-n%2^ (u-1)>0 and'1'or'0')end;return l end)..'0000'):gsub('%d%d%d?%d?%d?%d?',function(d)if(
#d<6)then return''end;local l=0;for u=1,6 do l=l+
(d:sub(u,u)=='1'and 2^ (6-u)or 0)end;return
n:sub(l+1,l+1)end).. ({'','==','='})[#r%3+1])end
local function h(r)r=string.gsub(r,'[^'..n..'=]','')
return
(r:gsub('.',function(d)if(d=='=')then
return''end;local l,u='',(n:find(d)-1)for c=6,1,-1 do
l=l.. (
u%2^c-u%2^ (c-1)>0 and'1'or'0')end;return l end):gsub('%d%d%d?%d?%d?%d?%d?%d?',function(d)if(
#d~=8)then return''end;local l=0
for u=1,8 do l=l+ (
d:sub(u,u)=='1'and 2^ (8-u)or 0)end;return string.char(l)end))end;return{encode=s,decode=h}end
a["lib.30log"]=function(...)
local n,s,h,r,d,l,u,c,m,f=next,assert,pairs,type,tostring,setmetatable,{},setmetatable({},{__mode='k'}),setmetatable({},{__mode='k'})local function w(j,x)
s(m[j],('Wrong method call. Expected class:%s.'):format(x))end;local function y(j,x)
s(c[j],('Wrong method call. Expected instance:%s.'):format(x))end;local function p(j,x)
return function(...)return j(x,...)end end;local v=function()return true end
local function b(j,x,z)
j=j or{}local _=x or{}
for E,T in h(j)do
if z~=nil and r(T)==z then
_[E]=(r(T)=='table')and(
(m[T]or c[T])and T or b(T))or T elseif z==nil then
_[E]=(r(T)=='table')and E~='__index'and(
(m[T]or c[T])and T or b(T))or T end end;return _ end
local function g(j,x,...)w(x,'new(...) or class(...)')local z={class=x}c[z]=d(z)
b(x,z,'table')z.__index,z.__subclasses,z.__instances,z.mixins=nil,nil,nil,nil;l(z,x)if
j and x.init then
if r(x.init)=='table'then b(x.init,z)else x.init(z,...)end end;return z end
local function k(j,x,z)w(j,'extend(...)')local _={}m[_]=d(_)j.__subclasses[_]=true
b(z,b(j,_))_.name,_.__index,_.super,_.mixins=z and z.name or x,_,j,{}
return l(_,j)end
u={__call=function(j,...)return j:new(...)end,__tostring=function(j,...)if c[j]then
return("instance of '%s' (%s)"):format(
rawget(j.class,'name')or'?',c[j])end;return
m[j]and("class '%s' (%s)"):format(
rawget(j,'name')or'?',m[j])or j end}m[u]=d(u)l(u,{__tostring=u.__tostring})
local q={isClass=function(j)
return not not m[j]end,isInstance=function(j)return not not c[j]end}
f=function(j,x)local z=b(x)m[z]=d(z)
z.name,z.__tostring,z.__call,z.new,z.create,z.extend,z.__index,z.mixins,z.__instances,z.__subclasses=j or z.name,u.__tostring,u.__call,p(g,true),p(g,false),k,z,l({},{__mode='k'}),l({},{__mode='k'}),l({},{__mode='k'})
z.subclasses=function(_,E,...)w(_,'subclasses(class)')E=E or v;local T={}for q in h(m)do
if q~=u and
q:subclassOf(_)and E(q,...)then T[#T+1]=q end end;return T end
z.instances=function(_,E,...)w(_,'instances(class)')E=E or v;local T={}
for A in h(c)do if A:instanceOf(_)and
E(A,...)then T[#T+1]=A end end;return T end
z.subclassOf=function(_,E)w(_,'subclassOf(superclass)')
s(q.isClass(E),'Wrong argument given to method "subclassOf()". Expected a class.')local T=_.super;while T do if T==E then return true end;T=T.super end
return false end
z.classOf=function(_,E)w(_,'classOf(subclass)')
s(q.isClass(E),'Wrong argument given to method "classOf()". Expected a class.')return E:subclassOf(_)end
z.instanceOf=function(_,E)y(_,'instanceOf(class)')
s(q.isClass(E),'Wrong argument given to method "instanceOf()". Expected a class.')return
((_.class==E)or(_.class:subclassOf(E)))end
z.cast=function(_,E)y(_,'instanceOf(class)')
s(q.isClass(E),'Wrong argument given to method "cast()". Expected a class.')l(_,E)_.class=E;return _ end
z.with=function(_,...)w(_,'with(mixin)')
for E,T in ipairs({...})do
s(_.mixins[T]~=true,('Attempted to include a mixin which was already included in %s'):format(d(_)))_.mixins[T]=true;b(T,_,'function')end;return _ end
z.includes=function(_,E)w(_,'includes(mixin)')return
not not(_.mixins[E]or
(_.super and _.super:includes(E)))end
z.without=function(_,...)w(_,'without(mixin)')
for E,T in ipairs({...})do
s(_.mixins[T]==true,('Attempted to remove a mixin which is not included in %s'):format(d(_)))local A=_:subclasses()A[#A+1]=_;for E,q in ipairs(A)do for O,I in h(T)do
if r(I)=='function'then q[O]=nil end end end;_.mixins[T]=
nil end;return _ end;return l(z,u)end;q._DESCRIPTION='30 lines library for object orientation in Lua'
q._VERSION='30log v1.2.0'q._URL='http://github.com/Yonaba/30log'
q._LICENSE='MIT LICENSE <http://www.opensource.org/licenses/mit-license.php>'
return l(q,{__call=function(j,...)return f(...)end})end
a["receiver.Receiver"]=function(...)local n=i"lib.30log"local s=n"Receiver"function s:init()end;function s:receive()
return nil end;return s end
a["receiver.DummyReceiver"]=function(...)local n=i"lib.30log"local s=i"receiver.Receiver"
local h=s:extend"DummyReceiver"local r=i"packet.Packet"local d=i"packet.Target"
function h:receive()sleep(5)local l=d(1,true)
local u=d(2,false)local c=r("VEhJUyBJUyBBIFBBQ0tFVA==",l,u)return c end;return h end
a["receiver.RednetReceiver"]=function(...)local n=i"lib.30log"local s=i"receiver.Receiver"
local h=s:extend"RednetReceiver"local r=i"packet.Packet"local d=i"packet.Target"
function h:receive()
local l={os.pullEvent()}
while l[1]~="rednet_message"do l={os.pullEvent()}end;local u=d(os.getComputerID(),true)local c=d(l[2],false)
local m=r(l[3],u,c)return m end;return h end
a["packet.Target"]=function(...)local n=i"lib.30log"local s=n"Target"function s:init(h,r)self._channel=h;self._isSelf=
r and r or false end;function s:getTarget()return
self._channel end
function s:isSelf()return self._isSelf end;return s end
a["packet.Packet"]=function(...)local n=i"lib.30log"local s=n"Packet"function s:init(h,r,d)self._content=h
self._target=r;self._source=d end;function s:getContent()
return self._content end;function s:getTarget()return self._target end;function s:getSource()return
self._source end
function s:setContent(h)self._content=h end;function s:setTarget(h)self._target=h end
function s:setSource(h)self._source=h end;return s end
a["processor.Base64Processor"]=function(...)local n=i"lib.base64"local s=i"lib.30log"
local h=i"processor.Processor"local r=h:extend("Base64Processor")
function r:process(d)if
(d:getTarget():isSelf())then d:setContent(n.decode(d:getContent()))else
d:setContent(n.encode(d:getContent()))end;return d end;return r end
a["processor.ProcessorChain"]=function(...)local n=i"lib.30log"local s=n"ProcessorChain"function s:init(h)
self._processors=h end;function s:process(h)
for r,d in pairs(self._processors)do h=d:process(h)end;return h end;return s end
a["processor.Processor"]=function(...)local n=i"lib.30log"local s=n"Processor"function s:init()end;function s:process(h)
return h end;return s end
a["transmitter.Transmitter"]=function(...)local n=i"lib.30log"local s=n"Transmitter"
function s:init()end;function s:transmit(h)end;return s end
a["transmitter.RednetTransmitter"]=function(...)local n=i"lib.30log"local s=i"receiver.Receiver"
local h=s:extend"RednetTransmitter"function h:transmit(r)
rednet.send(r:getTarget():getTarget(),r:getContent())end;return h end
a["transmitter.DummyTransmitter"]=function(...)local n=i"lib.30log"
local s=i"transmitter.Transmitter"local h=s:extend"DummyTransmitter"
function h:transmit(r)print"TRANSMITTED"return true end;return h end
a["wrapper.Wrapper"]=function(...)local n=i"lib.30log"local s=i"processor.ProcessorChain"
local h=i"packet.Packet"local r=n"Wrapper"
local function d(l)if(type(l)~="table")then return l end;local u={}for c,m in
pairs(l)do u[d(c)]=d(m)end
u=setmetatable(u,d(getmetatable(l)))return u end
function r:init(l,u,c,m)self._receiver=l;self._transmitter=u;self._inProcessors=s(c)
self._outProcessors=s(m)self._packetQueue={}self._receiveQueue={}self._sendQueue={}
self._handlers={}end
function r:addHandler(l)table.insert(self._handlers,l)end
function r:send(l)table.insert(self._packetQueue,l)end
function r:run()
parallel.waitForAny(function()while true do local l=self._receiver:receive()
if
(l~=nil)then table.insert(self._packetQueue,l)end;sleep(0)end end,function()
while
true do local l={}
for u,c in pairs(self._packetQueue)do
if
(c:getTarget():isSelf())then c=self._inProcessors:process(c)
table.insert(self._receiveQueue,c)else c=self._outProcessors:process(c)
table.insert(self._sendQueue,c)end end;self._packetQueue={}sleep(0)end end,function()
while
true do
if(#self._sendQueue>0)then for l,u in pairs(self._sendQueue)do
self._transmitter:transmit(u)end;self._sendQueue={}end;sleep(0)end end,function()
while
true do
if(#self._receiveQueue>0)then
for l,u in pairs(self._receiveQueue)do for c,m in
pairs(self._handlers)do
m(u,function(f)
self:send(h(f,u:getSource(),u:getTarget()))end)end end;self._receiveQueue={}end;sleep(0)end end)end;return r end
a["dentatsu.dentatsu"]=function(...)local n={}n.receiver={}n.transmitter={}n.processor={}
n.wrapper={}n.receiver.Receiver=i"receiver.Receiver"
n.receiver.Dummy=i"receiver.DummyReceiver"n.receiver.Rednet=i"receiver.RednetReceiver"
n.transmitter.Transmitter=i"transmitter.Transmitter"n.transmitter.Dummy=i"transmitter.DummyTransmitter"
n.transmitter.Rednet=i"transmitter.RednetTransmitter"n.processor.Processor=i"processor.Processor"
n.processor.Base64=i"processor.Base64Processor"n.wrapper.Wrapper=i"wrapper.Wrapper"return n end;return a["dentatsu.dentatsu"](...)