0001    #if os(Linux)
0002        import Glibc
0003    #else
0004        import Darwin
0005    #endif
0006    
0007    final class ConcurrentQueue
ConcurrentQueue.swift:32
extension ConcurrentQueue: DispatchQueue {
Echo.swift:10
    let globalQueue: ConcurrentQueue
Echo.swift:14
        globalQueue = ConcurrentQueue(identifier: "com.queue.global")
 {
0008        let identifier
ConcurrentQueue.swift:19
        self.identifier = identifier
: String
0009        
0010        var events
ConcurrentQueue.swift:20
        self.events = []
ConcurrentQueue.swift:47
                while self.events.count > 0 {
ConcurrentQueue.swift:49
                    let event = self.events.removeFirst()
: [() -> ()]
0011        
0012        var eventMutex
ConcurrentQueue.swift:21
        self.eventMutex = pthread_mutex_t()
ConcurrentQueue.swift:38
            pthread_mutex_init(&self.eventMutex, nil)
ConcurrentQueue.swift:48
                    pthread_mutex_lock(&self.eventMutex)
ConcurrentQueue.swift:50
                    pthread_mutex_unlock(&self.eventMutex)
: pthread_mutex_t
0013        
0014        var eventCondition
ConcurrentQueue.swift:22
        self.eventCondition = pthread_cond_t()
ConcurrentQueue.swift:42
            pthread_cond_init (&self.eventCondition, nil)
ConcurrentQueue.swift:58
                pthread_cond_wait(&self.eventCondition, &conditionMutex)
: pthread_cond_t
0015        
0016        var loopThread
ConcurrentQueue.swift:26
        self.loopThread = pthread_t(nil)
ConcurrentQueue.swift:62
        runBlock(block, onThread: &loopThread)
: pthread_t
0017        
0018        init
Echo.swift:14
        globalQueue = ConcurrentQueue(identifier: "com.queue.global")
(identifier: String) {
0019            self.identifier = identifier
0020            self.events = []
0021            self.eventMutex = pthread_mutex_t()
0022            self.eventCondition = pthread_cond_t()
0023            #if os(Linux)
0024            self.loopThread = pthread_t()
0025            #else
0026            self.loopThread = pthread_t(nil)
0027            #endif
0028            run()
0029        }
0030    }
0031    
0032    extension ConcurrentQueue: DispatchQueue {
0033        
0034        func run
ConcurrentQueue.swift:28
        run()
() {
0035            let block = {
0036                var conditionMutex = pthread_mutex_t()
0037                
0038                pthread_mutex_init(&self.eventMutex, nil)
0039                
0040                pthread_mutex_init(&conditionMutex, nil)
0041                
0042                pthread_cond_init (&self.eventCondition, nil)
0043                
0044                pthread_mutex_lock(&conditionMutex)
0045                
0046                while true {
0047                    while self.events.count > 0 {
0048                        pthread_mutex_lock(&self.eventMutex)
0049                        let event = self.events.removeFirst()
0050                        pthread_mutex_unlock(&self.eventMutex)
0051                        #if os(Linux)
0052                        var thread = pthread_t()
0053                        #else
0054                        var thread = pthread_t(nil)
0055                        #endif
0056                        self.runBlock(event, onThread: &thread)
0057                    }
0058                    pthread_cond_wait(&self.eventCondition, &conditionMutex)
0059                }
0060            }
0061            
0062            runBlock(block, onThread: &loopThread)
0063        }
0064        
0065    }
0066