NSLock.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//


#if os(macOS) || os(iOS)
import Darwin
#elseif os(Linux) || CYGWIN
import Glibc
#endif

import CoreFoundation

publicprotocolNSLocking{
func lock()
func unlock()
}

#if CYGWIN
privatetypealias_PthreadMutexPointer=UnsafeMutablePointer<pthread_mutex_t?>
privatetypealias_PthreadCondPointer=UnsafeMutablePointer<pthread_cond_t?>
#else
privatetypealias_PthreadMutexPointer=UnsafeMutablePointer<pthread_mutex_t>
privatetypealias_PthreadCondPointer=UnsafeMutablePointer<pthread_cond_t>
#endif

openclassNSLock:NSObject,NSLocking{
internalvarmutex= _PthreadMutexPointer.allocate(capacity:1)
#if os(macOS) || os(iOS)
privatevartimeoutCond= _PthreadCondPointer.allocate(capacity:1)
privatevartimeoutMutex= _PthreadMutexPointer.allocate(capacity:1)
#endif

publicoverrideinit(){
pthread_mutex_init(mutex,nil)
#if os(macOS) || os(iOS)
pthread_cond_init(timeoutCond,nil)
pthread_mutex_init(timeoutMutex,nil)
#endif
}

deinit{
pthread_mutex_destroy(mutex)
 mutex.deinitialize(count:1)
 mutex.deallocate()
#if os(macOS) || os(iOS)
deallocateTimedLockData(cond: timeoutCond, mutex: timeoutMutex)
#endif
}

openfunc lock(){
pthread_mutex_lock(mutex)
}

openfunc unlock(){
pthread_mutex_unlock(mutex)
#if os(macOS) || os(iOS)
 // Wakeup any threads waiting in lock(before:)
pthread_mutex_lock(timeoutMutex)
pthread_cond_broadcast(timeoutCond)
pthread_mutex_unlock(timeoutMutex)
#endif
}

openfunc `try`()->Bool{
returnpthread_mutex_trylock(mutex)==0
}

openfunc lock(before limit:Date)->Bool{
ifpthread_mutex_trylock(mutex)==0{
returntrue
}

#if os(macOS) || os(iOS)
returntimedLock(mutex: mutex, endTime: limit, using: timeoutCond, with: timeoutMutex)
#else
guardvar endTime =timeSpecFrom(date: limit)else{
returnfalse
}
returnpthread_mutex_timedlock(mutex,&endTime)==0
#endif
}

openvarname:String?
}

extensionNSLock{
internalfunc synchronized<T>(_ closure:()->T)->T{
self.lock()
defer{self.unlock()}
returnclosure()
}
}

openclassNSConditionLock:NSObject,NSLocking{
internalvar_cond=NSCondition()
internalvar_value:Int
internalvar_thread:pthread_t?

publicconvenienceoverrideinit(){
self.init(condition:0)
}

publicinit(condition:Int){
 _value = condition
}

openfunc lock(){
let _ =lock(before:Date.distantFuture)
}

openfunc unlock(){
 _cond.lock()
 _thread =nil
 _cond.broadcast()
 _cond.unlock()
}

openvarcondition:Int{
return _value
}

openfunc lock(whenCondition condition:Int){
let _ =lock(whenCondition: condition, before:Date.distantFuture)
}

openfunc `try`()->Bool{
returnlock(before:Date.distantPast)
}

openfunc tryLock(whenCondition condition:Int)->Bool{
returnlock(whenCondition: condition, before:Date.distantPast)
}

openfunc unlock(withCondition condition:Int){
 _cond.lock()
 _thread =nil
 _value = condition
 _cond.broadcast()
 _cond.unlock()
}

openfunc lock(before limit:Date)->Bool{
 _cond.lock()
while _thread !=nil{
if !_cond.wait(until: limit){
 _cond.unlock()
returnfalse
}
}
 _thread =pthread_self()
 _cond.unlock()
returntrue
}

openfunc lock(whenCondition condition:Int, before limit:Date)->Bool{
 _cond.lock()
while _thread !=nil || _value != condition {
if !_cond.wait(until: limit){
 _cond.unlock()
returnfalse
}
}
 _thread =pthread_self()
 _cond.unlock()
returntrue
}

openvarname:String?
}

openclassNSRecursiveLock:NSObject,NSLocking{
internalvarmutex= _PthreadMutexPointer.allocate(capacity:1)
#if os(macOS) || os(iOS)
privatevartimeoutCond= _PthreadCondPointer.allocate(capacity:1)
privatevartimeoutMutex= _PthreadMutexPointer.allocate(capacity:1)
#endif

publicoverrideinit(){
 super.init()
#if CYGWIN
varattrib:pthread_mutexattr_t?=nil
#else
varattrib=pthread_mutexattr_t()
#endif
withUnsafeMutablePointer(to:&attrib){ attrs in
pthread_mutexattr_settype(attrs,Int32(PTHREAD_MUTEX_RECURSIVE))
pthread_mutex_init(mutex, attrs)
}
}

deinit{
pthread_mutex_destroy(mutex)
 mutex.deinitialize(count:1)
 mutex.deallocate()
#if os(macOS) || os(iOS)
deallocateTimedLockData(cond: timeoutCond, mutex: timeoutMutex)
#endif
}

openfunc lock(){
pthread_mutex_lock(mutex)
}

openfunc unlock(){
pthread_mutex_unlock(mutex)
#if os(macOS) || os(iOS)
 // Wakeup any threads waiting in lock(before:)
pthread_mutex_lock(timeoutMutex)
pthread_cond_broadcast(timeoutCond)
pthread_mutex_unlock(timeoutMutex)
#endif
}

openfunc `try`()->Bool{
returnpthread_mutex_trylock(mutex)==0
}

openfunc lock(before limit:Date)->Bool{
ifpthread_mutex_trylock(mutex)==0{
returntrue
}

#if os(macOS) || os(iOS)
returntimedLock(mutex: mutex, endTime: limit, using: timeoutCond, with: timeoutMutex)
#else
guardvar endTime =timeSpecFrom(date: limit)else{
returnfalse
}
returnpthread_mutex_timedlock(mutex,&endTime)==0
#endif
}

openvarname:String?
}

openclassNSCondition:NSObject,NSLocking{
internalvarmutex= _PthreadMutexPointer.allocate(capacity:1)
internalvarcond= _PthreadCondPointer.allocate(capacity:1)

publicoverrideinit(){
pthread_mutex_init(mutex,nil)
pthread_cond_init(cond,nil)
}

deinit{
pthread_mutex_destroy(mutex)
pthread_cond_destroy(cond)
 mutex.deinitialize(count:1)
 cond.deinitialize(count:1)
 mutex.deallocate()
 cond.deallocate()
}

openfunc lock(){
pthread_mutex_lock(mutex)
}

openfunc unlock(){
pthread_mutex_unlock(mutex)
}

openfunc wait(){
pthread_cond_wait(cond, mutex)
}

openfunc wait(until limit:Date)->Bool{
guardvar timeout =timeSpecFrom(date: limit)else{
returnfalse
}
returnpthread_cond_timedwait(cond, mutex,&timeout)==0
}

openfunc signal(){
pthread_cond_signal(cond)
}

openfunc broadcast(){
pthread_cond_broadcast(cond)
}

openvarname:String?
}

privatefunc timeSpecFrom(date:Date)->timespec?{
guard date.timeIntervalSinceNow >0else{
returnnil
}
letnsecPerSec:Int64=1_000_000_000
letinterval= date.timeIntervalSince1970
letintervalNS=Int64(interval * Double(nsecPerSec))

returntimespec(tv_sec:Int(intervalNS / nsecPerSec),
 tv_nsec:Int(intervalNS % nsecPerSec))
}

#if os(macOS) || os(iOS)

privatefunc deallocateTimedLockData(cond:_PthreadCondPointer, mutex:_PthreadMutexPointer){
pthread_cond_destroy(cond)
 cond.deinitialize(count:1)
 cond.deallocate()

pthread_mutex_destroy(mutex)
 mutex.deinitialize(count:1)
 mutex.deallocate()
}

// Emulate pthread_mutex_timedlock using pthread_cond_timedwait.
// lock(before:) passes a condition variable/mutex pair to use.
// unlock() will use pthread_cond_broadcast() to wake any waits in progress.
privatefunc timedLock(mutex:_PthreadMutexPointer, endTime:Date,
 using timeoutCond:_PthreadCondPointer,
 with timeoutMutex:_PthreadMutexPointer)->Bool{

vartimeSpec=timeSpecFrom(date: endTime)
whilevar ts = timeSpec {
letlockval=pthread_mutex_lock(timeoutMutex)
precondition(lockval ==0)
letwaitval=pthread_cond_timedwait(timeoutCond, timeoutMutex,&ts)
precondition(waitval ==0 || waitval == ETIMEDOUT)
letunlockval=pthread_mutex_unlock(timeoutMutex)
precondition(unlockval ==0)

if waitval == ETIMEDOUT {
returnfalse
}
lettryval=pthread_mutex_trylock(mutex)
precondition(tryval ==0 || tryval == EBUSY)
if tryval ==0{ // The lock was obtained.
returntrue
}
 // pthread_cond_timedwait didnt timeout so wait some more.
 timeSpec =timeSpecFrom(date: endTime)
}
returnfalse
}
#endif