events.lua v0.7

local ev = {}
rawset(_G,"events",ev)

local programStack = {}
local eventTable = {}
setmetatable(eventTable,{ __mode="v" })
setmetatable(programStack,{ __mode="v" })
local deletionQueue = {}
local osPullEvent = os.pullEvent
local osPullEventRaw = os.pullEventRaw

local function getTableID(tabl)
  return string.sub(tostring(tabl),8)
end

function isProgramRegistered( co, pID )
  if programStack[ co ] == nil then return false end
  for i,v in ipairs( programStack[co] ) do
    if v == pID then return true end
  end
  return false
end

local function getTablePos(checkTable,element)
  for k,v in pairs(checkTable) do
    if v == element then return k end
  end
  return false
end

local function queueDeletion(delTable,element)
  if deletionQueue[delTable] == nil then deletionQueue[delTable] = {} end
  local pos = getTablePos(deletionQueue[delTable],element)
  if not pos then table.insert(deletionQueue[delTable],element) end
end

local function executeDeletion()
  for k,v in pairs(deletionQueue) do
    for _,v2 in pairs(v) do
      local pos = getTablePos(k,v2)
      if pos then table.remove(k,pos) end
      if #k == 0 then k = nil  break end
    end
  end

  deletionQueue = {}
end

local function handleEvent(ev,...)
  if eventTable[ev] == nil or #eventTable[ev] == 0 then return false end
  local callTable = {}

  for _,v in pairs( eventTable[ev] ) do
    if v[2] ~= nil then
      table.insert(callTable,function() v[2](ev,unpack(arg)) end )
    else
      queueDeletion(eventTable[ev],v)
    end
  end
  executeDeletion()
  if #callTable > 0 then
    parallel.waitForAll(unpack(callTable))
    return true
  else
    return false
  end
end

local function insertEvent(co, event, regTable)
  if programStack[co] == nil then
    error("Trying to insert event for unregistered coroutine")
  end
  if eventTable[event] == nil then
    eventTable[event] = {}
  end
  setmetatable(regTable, { __mode = "v" } )
  table.insert(eventTable[event],regTable)
  table.insert(programStack[co][#programStack[co]],regTable)
end

function _G.events.registerEvent(event, callback)
  if callback == nil then error("No callback specified") end
  local regTable = {event,callback}
  insertEvent(coroutine.running(), event, regTable)
  return regTable
end

function _G.events.getCounts()
  local ret = {{"main",#eventTable}}
  for k,v in pairs(eventTable) do
    if v then
      table.insert(ret,{k,#v})
    end
  end
  return ret
end

function _G.events.unregisterEvent(regID,holdDeletion)
  holdDeletion = holdDeletion or false
  local event = regID[1]

  if eventTable[event] == nil or #eventTable[event] == 0 then return end

  queueDeletion(eventTable[event],regID)
  if not holdDeletion then
    executeDeletion()
  end

  if #eventTable[event] == 0 then eventTable[event] = nil end
end

function clearProgramEvents( co, pID )
  if programStack[co] == nil then return end
  for _,v in ipairs( programStack[co] ) do
    if v == pID then
      for _,v2 in ipairs(v) do
        events.unregisterEvent(v2,true)
      end
    end
  end
  executeDeletion()
end

function registerProgram( co, pID )
  if programStack[ co ] == nil then
    programStack[ co ] = {}
  end
  table.insert(programStack[co],pID)
end

function unregisterProgram( co, pID )
  if not isProgramRegistered( co, pID ) then return end
  clearProgramEvents( co, pID )
  queueDeletion(programStack[co],pID)
  executeDeletion()

end

local orgrun = os.run
function os.run( _tEnv, _sPath, ... )
  local pID = {}
  registerProgram( coroutine.running(), pID )
  orgrun( _tEnv, _sPath, unpack({...}) )
  unregisterProgram( coroutine.running(), pID)
end

while true do
  local ev,p1,p2,p3,p4,p5,p6 = os.pullEvent()
  handleEvent(ev,p1,p2,p3,p4,p5,p6)
end