0001    #if os(Linux)
0002    import Glibc
0003    #else
0004    import Darwin.C
0005    #endif
0006    
0007    var sharedHandler
Arbiter.swift:72
    sharedHandler = signalHandler
Signals.swift:20
    signal(SIGTERM) { _ in sharedHandler?.handle(.Terminate) }
Signals.swift:21
    signal(SIGINT) { _ in sharedHandler?.handle(.Interrupt) }
Signals.swift:22
    signal(SIGQUIT) { _ in sharedHandler?.handle(.Quit) }
Signals.swift:23
    signal(SIGTTIN) { _ in sharedHandler?.handle(.TTIN) }
Signals.swift:24
    signal(SIGTTOU) { _ in sharedHandler?.handle(.TTOU) }
Signals.swift:25
    signal(SIGCHLD) { _ in sharedHandler?.handle(.Child) }
SyncronousWorker.swift:34
    sharedHandler = signals
SyncronousWorker.swift:60
      sharedHandler?.process()
SyncronousWorker.swift:88
    let (read, _, _) = select(listeners + [sharedHandler!.pipe[0]], [], [], timeout: timeout)
: SignalHandler?
0008    
0009    class SignalHandler
Arbiter.swift:48
  var signalHandler: SignalHandler!
Arbiter.swift:65
    signalHandler = try SignalHandler()
Arbiter.swift:73
    SignalHandler.registerSignals()
Signals.swift:7
var sharedHandler: SignalHandler?
SyncronousWorker.swift:30
    let signals = try SignalHandler()
SyncronousWorker.swift:35
    SignalHandler.registerSignals()
 {
0010      enum Signal
Signals.swift:29
  var signalQueue: [Signal] = []
Signals.swift:45
  func handle(signal: Signal) {
Signals.swift:50
  var callbacks: [Signal: () -> ()] = [:]
Signals.swift:51
  func register(signal: Signal, _ callback: () -> ()) {
 {
0011        case Interrupt
Arbiter.swift:66
    signalHandler.register(.Interrupt, handleINT)
Signals.swift:21
    signal(SIGINT) { _ in sharedHandler?.handle(.Interrupt) }
SyncronousWorker.swift:31
    signals.register(.Interrupt, handleQuit)

0012        case Quit
Arbiter.swift:67
    signalHandler.register(.Quit, handleQUIT)
Signals.swift:22
    signal(SIGQUIT) { _ in sharedHandler?.handle(.Quit) }
SyncronousWorker.swift:32
    signals.register(.Quit, handleQuit)

0013        case TTIN
Arbiter.swift:69
    signalHandler.register(.TTIN, handleTTIN)
Signals.swift:23
    signal(SIGTTIN) { _ in sharedHandler?.handle(.TTIN) }

0014        case TTOU
Arbiter.swift:70
    signalHandler.register(.TTOU, handleTTOU)
Signals.swift:24
    signal(SIGTTOU) { _ in sharedHandler?.handle(.TTOU) }

0015        case Terminate
Arbiter.swift:68
    signalHandler.register(.Terminate, handleTerminate)
Signals.swift:20
    signal(SIGTERM) { _ in sharedHandler?.handle(.Terminate) }
SyncronousWorker.swift:33
    signals.register(.Terminate, handleTerminate)

0016        case Child
Arbiter.swift:71
    signalHandler.register(.Child, handleChild)
Signals.swift:25
    signal(SIGCHLD) { _ in sharedHandler?.handle(.Child) }

0017      }
0018    
0019      class func registerSignals
Arbiter.swift:73
    SignalHandler.registerSignals()
SyncronousWorker.swift:35
    SignalHandler.registerSignals()
() {
0020        signal(SIGTERM) { _ in sharedHandler?.handle(.Terminate) }
0021        signal(SIGINT) { _ in sharedHandler?.handle(.Interrupt) }
0022        signal(SIGQUIT) { _ in sharedHandler?.handle(.Quit) }
0023        signal(SIGTTIN) { _ in sharedHandler?.handle(.TTIN) }
0024        signal(SIGTTOU) { _ in sharedHandler?.handle(.TTOU) }
0025        signal(SIGCHLD) { _ in sharedHandler?.handle(.Child) }
0026      }
0027    
0028      var pipe
Arbiter.swift:119
    let (read, _, _) = select([signalHandler.pipe[0]], [], [], timeout: timeout)
Arbiter.swift:123
        while try signalHandler.pipe[0].read(1).count > 0 {}
Signals.swift:32
    pipe = try Socket.pipe()
Signals.swift:34
    for socket in pipe {
Signals.swift:42
    pipe[1].send(".")
SyncronousWorker.swift:88
    let (read, _, _) = select(listeners + [sharedHandler!.pipe[0]], [], [], timeout: timeout)
: [Socket]
0029      var signalQueue
Signals.swift:46
    signalQueue.append(signal)
Signals.swift:56
    let result = !signalQueue.isEmpty
Signals.swift:58
    if !signalQueue.isEmpty {
Signals.swift:59
      if let handler = callbacks[signalQueue.removeFirst()] {
: [Signal] = []
0030    
0031      init
Arbiter.swift:65
    signalHandler = try SignalHandler()
SyncronousWorker.swift:30
    let signals = try SignalHandler()
() throws {
0032        pipe = try Socket.pipe()
0033    
0034        for socket in pipe {
0035          socket.closeOnExec = true
0036          socket.blocking = false
0037        }
0038      }
0039    
0040      // Wake up the process by writing to the pipe
0041      func wakeup
Signals.swift:47
    wakeup()
() {
0042        pipe[1].send(".")
0043      }
0044    
0045      func handle
Signals.swift:20
    signal(SIGTERM) { _ in sharedHandler?.handle(.Terminate) }
Signals.swift:21
    signal(SIGINT) { _ in sharedHandler?.handle(.Interrupt) }
Signals.swift:22
    signal(SIGQUIT) { _ in sharedHandler?.handle(.Quit) }
Signals.swift:23
    signal(SIGTTIN) { _ in sharedHandler?.handle(.TTIN) }
Signals.swift:24
    signal(SIGTTOU) { _ in sharedHandler?.handle(.TTOU) }
Signals.swift:25
    signal(SIGCHLD) { _ in sharedHandler?.handle(.Child) }
(signal: Signal) {
0046        signalQueue.append(signal)
0047        wakeup()
0048      }
0049    
0050      var callbacks
Signals.swift:52
    callbacks[signal] = callback
Signals.swift:59
      if let handler = callbacks[signalQueue.removeFirst()] {
: [Signal: () -> ()] = [:]
0051      func register
Arbiter.swift:66
    signalHandler.register(.Interrupt, handleINT)
Arbiter.swift:67
    signalHandler.register(.Quit, handleQUIT)
Arbiter.swift:68
    signalHandler.register(.Terminate, handleTerminate)
Arbiter.swift:69
    signalHandler.register(.TTIN, handleTTIN)
Arbiter.swift:70
    signalHandler.register(.TTOU, handleTTOU)
Arbiter.swift:71
    signalHandler.register(.Child, handleChild)
SyncronousWorker.swift:31
    signals.register(.Interrupt, handleQuit)
SyncronousWorker.swift:32
    signals.register(.Quit, handleQuit)
SyncronousWorker.swift:33
    signals.register(.Terminate, handleTerminate)
(signal: Signal, _ callback: () -> ()) {
0052        callbacks[signal] = callback
0053      }
0054    
0055      func process
Arbiter.swift:88
      if !signalHandler.process() {
SyncronousWorker.swift:60
      sharedHandler?.process()
() -> Bool {
0056        let result = !signalQueue.isEmpty
0057    
0058        if !signalQueue.isEmpty {
0059          if let handler = callbacks[signalQueue.removeFirst()] {
0060            handler()
0061          }
0062        }
0063    
0064        return result
0065      }
0066    }
0067