+(define (schedule-soonest-time schedule)
+ "Return a cons of (sec . usec) for next time segement, or #f if none"
+ (let ((segments (schedule-segments schedule)))
+ (if (eq? segments '())
+ #f
+ (time-segment-time (car segments)))))
+
+;; TODO: This code is reasonably easy to read but it
+;; mutates AND is worst case of O(n) in both space and time :(
+;; but at least it'll be reasonably easy to refactor to
+;; a more functional setup?
+(define (schedule-add! schedule time proc)
+ (let ((time (time-segment-right-format time)))
+ (define (new-time-segment)
+ (let ((new-segment
+ (make-time-segment time)))
+ (enq! (time-segment-queue new-segment) proc)
+ new-segment))
+ (define (loop segments)
+ (define (segment-equals-time? segment)
+ (time= time (time-segment-time segment)))
+
+ (define (segment-more-than-time? segment)
+ (time< time (time-segment-time segment)))
+
+ ;; We could switch this out to be more mutate'y
+ ;; and avoid the O(n) of space... is that over-optimizing?
+ (match segments
+ ;; If we're at the end of the list, time to make a new
+ ;; segment...
+ ('() (cons (new-time-segment) '()))
+ ;; If the segment's time is exactly our time, good news
+ ;; everyone! Let's append our stuff to its queue
+ (((? segment-equals-time? first) rest ...)
+ (enq! (time-segment-queue first) proc)
+ segments)
+ ;; If the first segment is more than our time,
+ ;; ours belongs before this one, so add it and
+ ;; start consing our way back
+ (((? segment-more-than-time? first) rest ...)
+ (cons (new-time-segment) segments))
+ ;; Otherwise, build up recursive result
+ ((first rest ... )
+ (cons first (loop rest)))))
+ (set-schedule-segments!
+ schedule
+ (loop (schedule-segments schedule)))))
+
+(define (schedule-empty? schedule)
+ (eq? (schedule-segments schedule) '()))
+
+(define (schedule-segments-split schedule time)
+ "Does a multiple value return of time segments before/at and after TIME"
+ (let ((time (time-segment-right-format time)))
+ (define (segment-is-now? segment)
+ (time= (time-segment-time segment) time))
+ (define (segment-is-before-now? segment)
+ (time< (time-segment-time segment) time))
+
+ (let loop ((segments-before '())
+ (segments-left (schedule-segments schedule)))
+ (match segments-left
+ ;; end of the line, return
+ ('()
+ (values (reverse segments-before) '()))
+
+ ;; It's right now, so time to stop, but include this one in before
+ ;; but otherwise return
+ (((? segment-is-now? first) rest ...)
+ (values (reverse (cons first segments-before)) rest))
+
+ ;; This is prior or at now, so add it and keep going
+ (((? segment-is-before-now? first) rest ...)
+ (loop (cons first segments-before) rest))
+
+ ;; Otherwise it's past now, just return what we have
+ (segments-after
+ (values segments-before segments-after))))))
+
+(define (schedule-extract-until! schedule time)
+ "Extract all segments until TIME from SCHEDULE, and pop old segments off"
+ (receive (segments-before segments-after)
+ (schedule-segments-split schedule time)
+ (set-schedule-segments! schedule segments-after)
+ segments-before))
+
+(define (add-segments-contents-to-queue! segments queue)
+ (for-each
+ (lambda (segment)
+ (let ((seg-queue (time-segment-queue segment)))
+ (while (not (q-empty? seg-queue))
+ (enq! queue (deq! seg-queue)))))
+ segments))
+
+
+\f
+;;; Port handling
+;;; =============
+
+(define (make-port-mapping)
+ (make-hash-table))
+
+(define* (port-mapping-set! port-mapping port #:optional read write except)
+ "Sets port-mapping for reader / writer / exception handlers"
+ (if (not (or read write except))
+ (throw 'no-handlers-given "No handlers given for port" port))
+ (hashq-set! port-mapping port
+ `#(,read ,write ,except)))
+
+(define (port-mapping-remove! port-mapping port)
+ (hashq-remove! port-mapping port))
+
+;; TODO: This is O(n), I'm pretty sure :\
+;; ... it might be worthwhile for us to have a
+;; port-mapping record that keeps a count of how many
+;; handlers (maybe via a promise?)
+(define (port-mapping-empty? port-mapping)
+ "Is this port mapping empty?"
+ (eq? (hash-count (const #t) port-mapping) 0))
+
+(define (port-mapping-non-empty? port-mapping)
+ "Whether this port-mapping contains any elements"
+ (not (port-mapping-empty? port-mapping)))
+
+
+\f
+;;; Request to run stuff
+;;; ====================
+
+(define-record-type <run-request>
+ (make-run-request proc when)
+ run-request?
+ (proc run-request-proc)
+ (when run-request-when))
+
+(define* (run proc #:optional when)
+ (make-run-request proc when))
+
+(define-syntax-rule (wrap body ...)
+ (lambda ()
+ body ...))
+
+(define-syntax-rule (run-wrap body ...)
+ (run (wrap body ...)))
+
+(define-syntax-rule (run-wrap-at body ... when)
+ (run (wrap body ...) when))
+
+\f
+;;; Execution of agenda, and current agenda
+;;; =======================================
+
+(define %current-agenda (make-parameter #f))
+
+(define (update-agenda-from-select! agenda)
+ (define (hash-keys hash)
+ (hash-map->list (lambda (k v) k) hash))
+ (define (get-wait-time)
+ ;; TODO: we need to figure this out based on whether there's anything
+ ;; in the queue, and if not, how long till the next scheduled item
+ (let ((soonest-time (schedule-soonest-time (agenda-schedule agenda))))
+ (cond
+ ((not (q-empty? (agenda-queue agenda)))
+ (cons 0 0))
+ (soonest-time ; ie, the agenda is non-empty
+ (let* ((current-time (agenda-time agenda)))
+ (if (time<= (pk 'soonest-time soonest-time) (pk 'current-time current-time))
+ ;; Well there's something due so let's select
+ ;; (this avoids a (possible?) race condition chance)
+ (cons 0 0)
+ (pk 'time-minus (time-minus soonest-time current-time)))))
+ (else
+ (cons #f #f)))))
+ (define (do-select)
+ ;; TODO: support usecond wait time too
+ (match (get-wait-time)
+ ((sec . usec)
+ (select (hash-keys (agenda-read-port-map agenda))
+ (hash-keys (agenda-write-port-map agenda))
+ (hash-keys (agenda-except-port-map agenda))
+ sec usec))))
+ (define (get-procs-to-run)
+ (define (ports->procs ports port-map)
+ (lambda (initial-procs)
+ (fold
+ (lambda (port prev)
+ (cons (lambda ()
+ ((hash-ref port-map port) port))
+ prev))
+ initial-procs
+ ports)))
+ (match (do-select)
+ ((read-ports write-ports except-ports)
+ ;; @@: Come on, we can do better than append ;P
+ ((compose (ports->procs
+ read-ports
+ (agenda-read-port-map agenda))
+ (ports->procs
+ write-ports
+ (agenda-write-port-map agenda))
+ (ports->procs
+ except-ports
+ (agenda-except-port-map agenda)))
+ '()))))
+ (define (update-agenda)
+ (let ((procs-to-run (get-procs-to-run))
+ (q (agenda-queue agenda)))
+ (for-each
+ (lambda (proc)
+ (enq! q proc))
+ procs-to-run))
+ agenda)
+ (define (ports-to-select?)
+ (define (has-items? selector)
+ ;; @@: O(n)
+ ;; ... we could use hash-for-each and a continuation to jump
+ ;; out with a #t at first indication of an item
+ (not (= (hash-count (const #t)
+ (selector agenda))
+ 0)))
+ (or (has-items? agenda-read-port-map)
+ (has-items? agenda-write-port-map)
+ (has-items? agenda-except-port-map)))
+
+ (if (ports-to-select?)
+ (update-agenda)
+ agenda))
+
+
+(define* (start-agenda agenda
+ #:key stop-condition
+ (get-time gettimeofday)
+ (handle-ports update-agenda-from-select!))