luajitos

Hook.lua (5083B)

---

 -- Hook.lua - Event hook system for LuajitOS
 -- Allows registering and running event callbacks with priority and control flow
 
 local Hook = {
     instances = {}
 }
 
 -- Create a new hook instance
 -- Returns a new hook object with add, remove, and run methods
 function Hook.newInstance()
     local instance = {
         hooks = {}  -- Structure: { [eventName] = { {name=hookName, func=callback}, ... } }
     }
 
     -- Add a hook for an event
     -- @param eventName: The name of the event to hook into
     -- @param hookName: Unique identifier for this hook
     -- @param callback: Function to call when event is triggered
     function instance:add(eventName, hookName, callback)
         if type(eventName) ~= "string" or eventName == "" then
             error("Hook.add: eventName must be a non-empty string")
         end
 
         if type(hookName) ~= "string" or hookName == "" then
             error("Hook.add: hookName must be a non-empty string")
         end
 
         if type(callback) ~= "function" then
             error("Hook.add: callback must be a function")
         end
 
         -- Initialize event hook list if it doesn't exist
         if not self.hooks[eventName] then
             self.hooks[eventName] = {}
         end
 
         -- Check if hook with this name already exists for this event
         for i, hook in ipairs(self.hooks[eventName]) do
             if hook.name == hookName then
                 -- Replace existing hook
                 hook.func = callback
                 return
             end
         end
 
         -- Add new hook
         table.insert(self.hooks[eventName], {
             name = hookName,
             func = callback
         })
     end
 
     -- Remove hook(s) from an event
     -- @param eventName: The name of the event
     -- @param hookName: (optional) Specific hook name to remove. If nil, removes all hooks for the event
     function instance:remove(eventName, hookName)
         if type(eventName) ~= "string" or eventName == "" then
             error("Hook.remove: eventName must be a non-empty string")
         end
 
         if not self.hooks[eventName] then
             return  -- No hooks for this event
         end
 
         if hookName == nil then
             -- Remove all hooks for this event
             self.hooks[eventName] = nil
         else
             -- Remove specific hook
             if type(hookName) ~= "string" then
                 error("Hook.remove: hookName must be a string or nil")
             end
 
             for i = #self.hooks[eventName], 1, -1 do
                 if self.hooks[eventName][i].name == hookName then
                     table.remove(self.hooks[eventName], i)
                     break
                 end
             end
 
             -- Clean up empty event table
             if #self.hooks[eventName] == 0 then
                 self.hooks[eventName] = nil
             end
         end
     end
 
     -- Run all hooks for an event
     -- @param eventName: The name of the event to trigger
     -- @param ...: Arguments to pass to each hook callback
     -- @return: true if any hook returned true (stopping execution), false otherwise
     function instance:run(eventName, ...)
         if type(eventName) ~= "string" or eventName == "" then
             error("Hook.run: eventName must be a non-empty string")
         end
 
         if not self.hooks[eventName] then
             return false  -- No hooks for this event
         end
 
         -- Run each hook in order
         for i, hook in ipairs(self.hooks[eventName]) do
             local success, result = pcall(hook.func, ...)
 
             if not success then
                 -- Hook threw an error - log it but continue
                 if osprint then
                     osprint("Hook error in '" .. eventName .. "' hook '" .. hook.name .. "': " .. tostring(result))
                 end
             elseif result == true then
                 -- Hook returned true - stop executing remaining hooks
                 return true
             end
         end
 
         return false
     end
 
     -- Get all hook names for an event
     -- @param eventName: The name of the event
     -- @return: Array of hook names, or empty array if no hooks
     function instance:getHooks(eventName)
         if type(eventName) ~= "string" or eventName == "" then
             error("Hook.getHooks: eventName must be a non-empty string")
         end
 
         if not self.hooks[eventName] then
             return {}
         end
 
         local names = {}
         for i, hook in ipairs(self.hooks[eventName]) do
             table.insert(names, hook.name)
         end
 
         return names
     end
 
     -- Get all event names that have hooks
     -- @return: Array of event names
     function instance:getEvents()
         local events = {}
         for eventName, _ in pairs(self.hooks) do
             table.insert(events, eventName)
         end
         return events
     end
 
     -- Clear all hooks from this instance
     function instance:clear()
         self.hooks = {}
     end
 
     -- Store instance
     table.insert(Hook.instances, instance)
 
     return instance
 end
 
 return Hook