From 3d8bdf1cf3d49253337080a65490eb1429feddc8 Mon Sep 17 00:00:00 2001
From: John Estropia <rommel.estropia@gmail.com>
Date: Tue, 22 Oct 2019 11:48:09 +0900
Subject: [PATCH] Remove references to OSAtomic to silence deprecation warnings

---
 .../Internals.DiffableDataUIDispatcher.swift  | 54 ++++++++++++++-----
 1 file changed, 40 insertions(+), 14 deletions(-)

diff --git a/Sources/Internals.DiffableDataUIDispatcher.swift b/Sources/Internals.DiffableDataUIDispatcher.swift
index 295e9aa..de370fb 100644
--- a/Sources/Internals.DiffableDataUIDispatcher.swift
+++ b/Sources/Internals.DiffableDataUIDispatcher.swift
@@ -184,24 +184,15 @@ extension Internals {
 
             // MARK: FilePrivate
 
-            fileprivate init() {
-
-                self.executingCount.initialize(to: 0)
-            }
-
-            deinit {
-
-                self.executingCount.deinitialize(count: 1)
-                self.executingCount.deallocate()
-            }
+            fileprivate init() {}
 
             fileprivate func dispatch(_ action: @escaping () -> Void) {
 
-                let count = OSAtomicIncrement32(self.executingCount)
+                let count = self.executingCount.incrementAndGet()
                 if Thread.isMainThread && count == 1 {
 
                     action()
-                    OSAtomicDecrement32(executingCount)
+                    self.executingCount.decrement()
                 }
                 else {
 
@@ -212,7 +203,7 @@ extension Internals {
                             return
                         }
                         action()
-                        OSAtomicDecrement32(self.executingCount)
+                        self.executingCount.decrement()
                     }
                 }
             }
@@ -220,7 +211,42 @@ extension Internals {
 
             // MARK: Private
 
-            private let executingCount: UnsafeMutablePointer<Int32> = .allocate(capacity: 1)
+            private let executingCount: AtomicInt = .init()
+
+            
+            // MARK: - AtomicInt
+            
+            fileprivate class AtomicInt {
+                
+                // MARK: FilePrivate
+
+                fileprivate func incrementAndGet() -> Int {
+
+                    self.lock.wait()
+                    defer {
+                        
+                        self.lock.signal()
+                    }
+                    self.value += 1
+                    return self.value
+                }
+
+                fileprivate func decrement() {
+
+                    self.lock.wait()
+                    defer {
+                        
+                        self.lock.signal()
+                    }
+                    self.value -= 1
+                }
+
+                
+                // MARK: Private
+
+                private let lock = DispatchSemaphore(value: 1)
+                private var value = 0
+            }
         }
         
     }