| extension String { | |
| func snakeCased() -> String? { | |
| let pattern = "([a-z0-9])([A-Z])" | |
| let regex = try? NSRegularExpression(pattern: pattern, options: []) | |
| let range = NSRange(location: 0, length: count) | |
| return regex?.stringByReplacingMatches(in: self, options: [], range: range, withTemplate: "$1_$2").lowercased() | |
| } | |
| } |
Foundation offers a Thread class, internally based on pthread, that can be used to create new threads and execute closures.
// Detaches a new thread and uses the specified selector as the thread entry point.
Thread.detachNewThreadSelector(selector: Selector>, toTarget: Any, with: Any)
// Subclass
class MyThread: Thread {
Let's say you receive an app (e.g. MyApp.ipa) from another developer, and you want to be able to install and run it on your devices (by using ideviceinstaller, for example).
Or your certificates and provision profiles have expired and you want to provide a new build to your clients without having to make a new build on the latest XCode or iOS SDK.
The first step is to attain a Provisioning Profile which includes all of the devices you wish to install and run on. Ensure that the profile contains a certificate that you have installed in your Keychain Access (e.g. iPhone Developer: Some Body (XXXXXXXXXX) ). Download the profile (MyProfile.mobileprovision) so you can replace the profile embedded in the app.
The libdispatch is one of the most misused API due to the way it was presented to us when it was introduced and for many years after that, and due to the confusing documentation and API. This page is a compilation of important things to know if you're going to use this library. Many references are available at the end of this document pointing to comments from Apple's very own libdispatch maintainer (Pierre Habouzit).
My take-aways are:
You should create very few, long-lived, well-defined queues. These queues should be seen as execution contexts in your program (gui, background work, ...) that benefit from executing in parallel. An important thing to note is that if these queues are all active at once, you will get as many threads running. In most apps, you probably do not need to create more than 3 or 4 queues.
Go serial first, and as you find performance bottle necks, measure why, and if concurrency helps, apply with care, always validating under system pressure. Reuse
| extension String { | |
| func snakeCased() -> String? { | |
| let pattern = "([a-z0-9])([A-Z])" | |
| let regex = try? NSRegularExpression(pattern: pattern, options: []) | |
| let range = NSRange(location: 0, length: self.characters.count) | |
| return regex?.stringByReplacingMatches(in: self, options: [], range: range, withTemplate: "$1_$2").lowercased() | |
| } | |
| } |
| import Foundation | |
| extension URLRequest { | |
| /** | |
| Returns a cURL command representation of this URL request. | |
| */ | |
| public var curlString: String { | |
| guard let url = url else { return "" } | |
| var baseCommand = #"curl "\#(url.absoluteString)""# |
| // | |
| // CXEImageToVideo.swift | |
| // VideoAPPTest | |
| // | |
| // Created by Wulei on 16/12/14. | |
| // Copyright © 2016年 wulei. All rights reserved. | |
| // | |
| import Foundation | |
| import AVFoundation |
| /** Throttle wraps a block with throttling logic, guarantueeing that the block will never be called (by enquueing | |
| asynchronously on `queue`) more than once each `interval` seconds. If the wrapper callback is called more than once | |
| in an interval, it will use the most recent call's parameters when eventually calling the wrapped block (after `interval` | |
| has elapsed since the last call to the wrapped function) - i.e. calls are not queued and may get 'lost' by being superseded | |
| by a newer call. */ | |
| public func throttle<P>(interval: TimeInterval, queue: DispatchQueue, _ block: ((P) -> ())) -> ((P) -> ()) { | |
| var lastExecutionTime: TimeInterval? = nil | |
| var scheduledExecutionParameters: P? = nil | |
| let mutex = Mutex() |
| /** A pthread-based recursive mutex lock. */ | |
| public class Mutex { | |
| private var mutex: pthread_mutex_t = pthread_mutex_t() | |
| public init() { | |
| var attr: pthread_mutexattr_t = pthread_mutexattr_t() | |
| pthread_mutexattr_init(&attr) | |
| pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) | |
| let err = pthread_mutex_init(&self.mutex, &attr) |