Trivial event handler

trivial-events.lisp

(defparameter *handlers* (make-hash-table))

(defun register (ev fun)
  (vector-push-extend fun (alexandria:ensure-gethash
                           ev *handlers*
                           (make-array 1 :fill-pointer 0
                                         :adjustable t))))

(defun send (type msg from)
  (let ((handler-list (gethash type *handlers*)))
    (loop for fun across handler-list do
             (when (funcall fun type msg from)
               (return)))))

(defun my-handler (type msg from)
  (format t "Got ~S from ~S (type ~S)~%" msg from type)
  nil)

(defun handle-it (type msg from)
  (format t "Handled ~S~%" type)
  t)

(defun didnt-get-called (type msg from)
  (format t "I shouldn't be called")
  nil)

(progn
 (register 'some-event #'my-handler)
 (register 'some-event #'handle-it)
 (register 'some-event #'didnt-get-called))

(send 'some-event "foo msg" 'me)

vs

(defmessage exit-request ())

(defmessage join-request ())

(defclass message-consumer ()
  ((some-context-here)))

(defmethod receive-message ((this message-consumer) (message exit-request))
  (format t "Exiting: ~S~%" (type-of message)))

(defmethod receive-message ((this message-consumer) (message join-request))
  (format t "Joining: ~S~%" (type-of message)))

;; somewhere in the init code
(defun init ()
  (let ((consumer (make-instance 'message-consumer)))
    (open-connection *host* *port0* consumer)
    (open-connection *host* *port1* consumer)))