cheykrym/socket.io-client-swift
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

only use self when needed

Browse Source
This commit is contained in:
Erik 2015-05-19 22:13:08 -04:00
parent 77ed87d0d4
commit 61b4628d3e
4 changed files with 277 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SocketIOClientSwift/SocketAckManager.swift
View File

@ -53,11 +53,11 @@ struct SocketAckManager {
private var acks = Set<SocketAck>(minimumCapacity: 1) private var acks = Set<SocketAck>(minimumCapacity: 1)
mutating func addAck(ack:Int, callback:AckCallback) { mutating func addAck(ack:Int, callback:AckCallback) {
self.acks.insert(SocketAck(ack: ack, callback: callback)) acks.insert(SocketAck(ack: ack, callback: callback))
} }
mutating func executeAck(ack:Int, items:[AnyObject]?) { mutating func executeAck(ack:Int, items:[AnyObject]?) {
let callback = self.acks.remove(SocketAck(ack: ack)) let callback = acks.remove(SocketAck(ack: ack))
dispatch_async(dispatch_get_main_queue()) { dispatch_async(dispatch_get_main_queue()) {
callback?.callback(items) callback?.callback(items)
@ -65,7 +65,7 @@ struct SocketAckManager {
} }
mutating func timeoutAck(ack:Int) { mutating func timeoutAck(ack:Int) {
let callback = self.acks.remove(SocketAck(ack: ack)) let callback = acks.remove(SocketAck(ack: ack))
dispatch_async(dispatch_get_main_queue()) { dispatch_async(dispatch_get_main_queue()) {
callback?.callback(["NO ACK"]) callback?.callback(["NO ACK"])

286
SocketIOClientSwift/SocketEngine.swift
View File

@ -59,21 +59,21 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
let logType = "SocketEngine" let logType = "SocketEngine"
var connected:Bool { var connected:Bool {
return self._connected return _connected
} }
weak var client:SocketEngineClient? weak var client:SocketEngineClient?
var cookies:[NSHTTPCookie]? var cookies:[NSHTTPCookie]?
var log = false var log = false
var pingInterval:Int? var pingInterval:Int?
var polling:Bool { var polling:Bool {
return self._polling return _polling
} }
var sid = "" var sid = ""
var socketPath = "" var socketPath = ""
var urlPolling:String? var urlPolling:String?
var urlWebSocket:String? var urlWebSocket:String?
var websocket:Bool { var websocket:Bool {
return self._websocket return _websocket
} }
var ws:WebSocket? var ws:WebSocket?
@ -98,16 +98,16 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
public init(client:SocketEngineClient, sessionDelegate:NSURLSessionDelegate?) { public init(client:SocketEngineClient, sessionDelegate:NSURLSessionDelegate?) {
self.client = client self.client = client
self.session = NSURLSession(configuration: NSURLSessionConfiguration.ephemeralSessionConfiguration(), self.session = NSURLSession(configuration: NSURLSessionConfiguration.ephemeralSessionConfiguration(),
delegate: sessionDelegate, delegateQueue: self.workQueue) delegate: sessionDelegate, delegateQueue: workQueue)
} }
public convenience init(client:SocketEngineClient, opts:NSDictionary?) { public convenience init(client:SocketEngineClient, opts:NSDictionary?) {
self.init(client: client, sessionDelegate: opts?["sessionDelegate"] as? NSURLSessionDelegate) self.init(client: client, sessionDelegate: opts?["sessionDelegate"] as? NSURLSessionDelegate)
self.forceWebsockets = opts?["forceWebsockets"] as? Bool ?? false forceWebsockets = opts?["forceWebsockets"] as? Bool ?? false
self.forcePolling = opts?["forcePolling"] as? Bool ?? false forcePolling = opts?["forcePolling"] as? Bool ?? false
self.cookies = opts?["cookies"] as? [NSHTTPCookie] cookies = opts?["cookies"] as? [NSHTTPCookie]
self.log = opts?["log"] as? Bool ?? false log = opts?["log"] as? Bool ?? false
self.socketPath = opts?["path"] as? String ?? "" socketPath = opts?["path"] as? String ?? ""
} }
deinit { deinit {
@ -117,21 +117,21 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
public func close(#fast:Bool) { public func close(#fast:Bool) {
SocketLogger.log("Engine is being closed. Fast: \(fast)", client: self) SocketLogger.log("Engine is being closed. Fast: \(fast)", client: self)
self.pingTimer?.invalidate() pingTimer?.invalidate()
self.closed = true closed = true
self.ws?.disconnect() ws?.disconnect()
if fast || self.polling { if fast || polling {
self.write("", withType: PacketType.CLOSE, withData: nil) write("", withType: PacketType.CLOSE, withData: nil)
self.client?.engineDidClose("Disconnect") client?.engineDidClose("Disconnect")
} }
self.stopPolling() stopPolling()
} }
private func createBinaryDataForSend(data:NSData) -> (NSData?, String?) { private func createBinaryDataForSend(data:NSData) -> (NSData?, String?) {
if self.websocket { if websocket {
var byteArray = [UInt8](count: 1, repeatedValue: 0x0) var byteArray = [UInt8](count: 1, repeatedValue: 0x0)
byteArray[0] = 4 byteArray[0] = 4
var mutData = NSMutableData(bytes: &byteArray, length: 1) var mutData = NSMutableData(bytes: &byteArray, length: 1)
@ -148,18 +148,18 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
} }
private func createURLs(params:[String: AnyObject]?) -> (String, String) { private func createURLs(params:[String: AnyObject]?) -> (String?, String?) {
if self.client == nil { if client == nil {
return ("", "") return (nil, nil)
} }
let path = self.socketPath == "" ? "/socket.io" : self.socketPath let path = socketPath == "" ? "/socket.io" : socketPath
var url = "\(self.client!.socketURL)\(path)/?transport=" var url = "\(client!.socketURL)\(path)/?transport="
var urlPolling:String var urlPolling:String
var urlWebSocket:String var urlWebSocket:String
if self.client!.secure { if client!.secure {
urlPolling = "https://" + url + "polling" urlPolling = "https://" + url + "polling"
urlWebSocket = "wss://" + url + "websocket" urlWebSocket = "wss://" + url + "websocket"
} else { } else {
@ -171,13 +171,13 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
for (key, value) in params! { for (key, value) in params! {
let keyEsc = key.stringByAddingPercentEncodingWithAllowedCharacters( let keyEsc = key.stringByAddingPercentEncodingWithAllowedCharacters(
self.allowedCharacterSet)! allowedCharacterSet)!
urlPolling += "&\(keyEsc)=" urlPolling += "&\(keyEsc)="
urlWebSocket += "&\(keyEsc)=" urlWebSocket += "&\(keyEsc)="
if value is String { if value is String {
let valueEsc = (value as! String).stringByAddingPercentEncodingWithAllowedCharacters( let valueEsc = (value as! String).stringByAddingPercentEncodingWithAllowedCharacters(
self.allowedCharacterSet)! allowedCharacterSet)!
urlPolling += "\(valueEsc)" urlPolling += "\(valueEsc)"
urlWebSocket += "\(valueEsc)" urlWebSocket += "\(valueEsc)"
} else { } else {
@ -191,48 +191,48 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
private func createWebsocket(andConnect connect:Bool) { private func createWebsocket(andConnect connect:Bool) {
self.ws = WebSocket(url: NSURL(string: self.urlWebSocket! + "&sid=\(self.sid)")!, ws = WebSocket(url: NSURL(string: urlWebSocket! + "&sid=\(sid)")!,
cookies: self.cookies) cookies: cookies)
self.ws?.queue = self.handleQueue ws?.queue = handleQueue
self.ws?.delegate = self ws?.delegate = self
if connect { if connect {
self.ws?.connect() ws?.connect()
} }
} }
private func doFastUpgrade() { private func doFastUpgrade() {
if self.waitingForPoll { if waitingForPoll {
SocketLogger.err("Outstanding poll when switched to WebSockets," + SocketLogger.err("Outstanding poll when switched to WebSockets," +
"we'll probably disconnect soon. You should report this.", client: self) "we'll probably disconnect soon. You should report this.", client: self)
} }
self.sendWebSocketMessage("", withType: PacketType.UPGRADE, datas: nil) sendWebSocketMessage("", withType: PacketType.UPGRADE, datas: nil)
self._websocket = true _websocket = true
self._polling = false _polling = false
self.fastUpgrade = false fastUpgrade = false
self.probing = false probing = false
self.flushProbeWait() flushProbeWait()
} }
private func doPoll() { private func doPoll() {
if self.websocket || self.waitingForPoll || !self.connected { if websocket || waitingForPoll || !connected {
return return
} }
self.waitingForPoll = true waitingForPoll = true
let req = NSMutableURLRequest(URL: NSURL(string: self.urlPolling! + "&sid=\(self.sid)&b64=1")!) let req = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&sid=\(sid)&b64=1")!)
if self.cookies != nil { if cookies != nil {
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!) let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
req.allHTTPHeaderFields = headers req.allHTTPHeaderFields = headers
} }
self.doRequest(req) doRequest(req)
} }
private func doRequest(req:NSMutableURLRequest) { private func doRequest(req:NSMutableURLRequest) {
if !self.polling { if !polling {
return return
} }
@ -240,7 +240,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
SocketLogger.log("Doing polling request", client: self) SocketLogger.log("Doing polling request", client: self)
self.session.dataTaskWithRequest(req) {[weak self] data, res, err in session.dataTaskWithRequest(req) {[weak self] data, res, err in
if let this = self { if let this = self {
if err != nil { if err != nil {
if this.polling { if this.polling {
@ -272,7 +272,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
private func flushProbeWait() { private func flushProbeWait() {
SocketLogger.log("Flushing probe wait", client: self) SocketLogger.log("Flushing probe wait", client: self)
dispatch_async(self.emitQueue) {[weak self] in dispatch_async(emitQueue) {[weak self] in
if let this = self { if let this = self {
for waiter in this.probeWait { for waiter in this.probeWait {
this.write(waiter.msg, withType: waiter.type, withData: waiter.data) this.write(waiter.msg, withType: waiter.type, withData: waiter.data)
@ -288,27 +288,27 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
private func flushWaitingForPost() { private func flushWaitingForPost() {
if self.postWait.count == 0 || !self.connected { if postWait.count == 0 || !connected {
return return
} else if self.websocket { } else if websocket {
self.flushWaitingForPostToWebSocket() flushWaitingForPostToWebSocket()
return return
} }
var postStr = "" var postStr = ""
for packet in self.postWait { for packet in postWait {
let len = count(packet) let len = count(packet)
postStr += "\(len):\(packet)" postStr += "\(len):\(packet)"
} }
self.postWait.removeAll(keepCapacity: false) postWait.removeAll(keepCapacity: false)
let req = NSMutableURLRequest(URL: NSURL(string: self.urlPolling! + "&sid=\(self.sid)")!) let req = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&sid=\(sid)")!)
if self.cookies != nil { if cookies != nil {
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!) let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
req.allHTTPHeaderFields = headers req.allHTTPHeaderFields = headers
} }
@ -321,11 +321,11 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
req.HTTPBody = postData req.HTTPBody = postData
req.setValue(String(postData.length), forHTTPHeaderField: "Content-Length") req.setValue(String(postData.length), forHTTPHeaderField: "Content-Length")
self.waitingForPost = true waitingForPost = true
SocketLogger.log("POSTing: \(postStr)", client: self) SocketLogger.log("POSTing: \(postStr)", client: self)
self.session.dataTaskWithRequest(req) {[weak self] data, res, err in session.dataTaskWithRequest(req) {[weak self] data, res, err in
if let this = self { if let this = self {
if err != nil && this.polling { if err != nil && this.polling {
this.handlePollingFailed(err.localizedDescription) this.handlePollingFailed(err.localizedDescription)
@ -349,63 +349,62 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
// We had packets waiting for send when we upgraded // We had packets waiting for send when we upgraded
// Send them raw // Send them raw
private func flushWaitingForPostToWebSocket() { private func flushWaitingForPostToWebSocket() {
for msg in self.postWait { for msg in postWait {
self.ws?.writeString(msg) ws?.writeString(msg)
} }
self.postWait.removeAll(keepCapacity: true) postWait.removeAll(keepCapacity: true)
} }
// A poll failed, tell the client about it // A poll failed, tell the client about it
private func handlePollingFailed(reason:String) { private func handlePollingFailed(reason:String) {
self._connected = false _connected = false
self.ws?.disconnect() ws?.disconnect()
self.pingTimer?.invalidate() pingTimer?.invalidate()
self.waitingForPoll = false waitingForPoll = false
self.waitingForPost = false waitingForPost = false
// If cancelled we were already closing // If cancelled we were already closing
if self.client == nil || reason == "cancelled" { if client == nil || reason == "cancelled" {
return return
} }
if !self.closed { if !closed {
self.client?.didError(reason) client?.didError(reason)
self.client?.engineDidClose(reason) client?.engineDidClose(reason)
} }
} }
public func open(opts:[String: AnyObject]? = nil) { public func open(opts:[String: AnyObject]? = nil) {
if self.connected { if connected {
SocketLogger.err("Tried to open while connected", client: self) SocketLogger.err("Tried to open while connected", client: self)
self.client?.didError("Tried to open while connected") client?.didError("Tried to open while connected")
return return
} }
SocketLogger.log("Starting engine", client: self) SocketLogger.log("Starting engine", client: self)
SocketLogger.log("Handshaking", client: self) SocketLogger.log("Handshaking", client: self)
self.closed = false closed = false
let (urlPolling, urlWebSocket) = self.createURLs(opts)
self.urlPolling = urlPolling
self.urlWebSocket = urlWebSocket
if self.forceWebsockets { (urlPolling, urlWebSocket) = createURLs(opts)
self._polling = false
self._websocket = true if forceWebsockets {
self.createWebsocket(andConnect: true) _polling = false
_websocket = true
createWebsocket(andConnect: true)
return return
} }
let reqPolling = NSMutableURLRequest(URL: NSURL(string: urlPolling + "&b64=1")!) let reqPolling = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&b64=1")!)
if self.cookies != nil { if cookies != nil {
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!) let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
reqPolling.allHTTPHeaderFields = headers reqPolling.allHTTPHeaderFields = headers
} }
self.doRequest(reqPolling) doRequest(reqPolling)
} }
// Translatation of engine.io-parser#decodePayload // Translatation of engine.io-parser#decodePayload
@ -439,7 +438,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
if length == "" || testLength(length, &n) { if length == "" || testLength(length, &n) {
SocketLogger.err("Parsing error: \(str)", client: self) SocketLogger.err("Parsing error: \(str)", client: self)
self.handlePollingFailed("Error parsing XHR message") handlePollingFailed("Error parsing XHR message")
return return
} }
@ -454,7 +453,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
if msg.length != 0 { if msg.length != 0 {
// Be sure to capture the value of the msg // Be sure to capture the value of the msg
dispatch_async(self.handleQueue) {[weak self, msg] in dispatch_async(handleQueue) {[weak self, msg] in
self?.parseEngineMessage(msg, fromPolling: true) self?.parseEngineMessage(msg, fromPolling: true)
} }
} }
@ -466,7 +465,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
private func parseEngineData(data:NSData) { private func parseEngineData(data:NSData) {
if let client = self.client { if let client = client {
dispatch_async(client.handleQueue) {[weak self] in dispatch_async(client.handleQueue) {[weak self] in
self?.client?.parseBinaryData(data.subdataWithRange(NSMakeRange(1, data.length - 1))) self?.client?.parseBinaryData(data.subdataWithRange(NSMakeRange(1, data.length - 1)))
} }
@ -486,17 +485,17 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
// Remove message type // Remove message type
message.removeAtIndex(message.startIndex) message.removeAtIndex(message.startIndex)
if let client = self.client { if let client = client {
dispatch_async(client.handleQueue) {[weak self] in dispatch_async(client.handleQueue) {[weak self] in
self?.client?.parseSocketMessage(message) self?.client?.parseSocketMessage(message)
} }
} }
} else if type == PacketType.NOOP { } else if type == PacketType.NOOP {
self.doPoll() doPoll()
} else if type == PacketType.PONG { } else if type == PacketType.PONG {
// We should upgrade // We should upgrade
if message == "3probe" { if message == "3probe" {
self.upgradeTransport() upgradeTransport()
} }
} else if type == PacketType.OPEN { } else if type == PacketType.OPEN {
var err:NSError? var err:NSError?
@ -508,32 +507,28 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
options: NSJSONReadingOptions.AllowFragments, options: NSJSONReadingOptions.AllowFragments,
error: &err) as? NSDictionary, let sid = json["sid"] as? String { error: &err) as? NSDictionary, let sid = json["sid"] as? String {
self.sid = sid self.sid = sid
self._connected = true _connected = true
if !self.forcePolling && !self.forceWebsockets { if !forcePolling && !forceWebsockets {
self.createWebsocket(andConnect: true) createWebsocket(andConnect: true)
} }
if let pingInterval = json["pingInterval"] as? Int { if let pingInterval = json["pingInterval"] as? Int {
self.pingInterval = pingInterval / 1000 self.pingInterval = pingInterval / 1000
} }
} else { } else {
self.client?.didError("Engine failed to handshake") client?.didError("Engine failed to handshake")
return return
} }
self.startPingTimer() startPingTimer()
if !self.forceWebsockets { if !forceWebsockets {
self.doPoll() doPoll()
} }
} else if type == PacketType.CLOSE { } else if type == PacketType.CLOSE {
if self.client == nil { if polling {
return client?.engineDidClose("Disconnect")
}
if self.polling {
self.client!.engineDidClose("Disconnect")
} }
} else if message.hasPrefix("b4") { } else if message.hasPrefix("b4") {
// binary in base64 string // binary in base64 string
@ -541,7 +536,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
end: advance(message.startIndex, 2))) end: advance(message.startIndex, 2)))
if let data = NSData(base64EncodedString: message, if let data = NSData(base64EncodedString: message,
options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters), client = self.client { options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters), client = client {
dispatch_async(client.handleQueue) {[weak self] in dispatch_async(client.handleQueue) {[weak self] in
self?.client?.parseBinaryData(data) self?.client?.parseBinaryData(data)
} }
@ -550,22 +545,22 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
private func probeWebSocket() { private func probeWebSocket() {
if self.websocketConnected { if websocketConnected {
self.sendWebSocketMessage("probe", withType: PacketType.PING) sendWebSocketMessage("probe", withType: PacketType.PING)
} }
} }
/// Send an engine message (4) /// Send an engine message (4)
public func send(msg:String, withData datas:ContiguousArray<NSData>?) { public func send(msg:String, withData datas:ContiguousArray<NSData>?) {
if self.probing { if probing {
self.probeWait.append((msg, PacketType.MESSAGE, datas)) probeWait.append((msg, PacketType.MESSAGE, datas))
} else { } else {
self.write(msg, withType: PacketType.MESSAGE, withData: datas) write(msg, withType: PacketType.MESSAGE, withData: datas)
} }
} }
func sendPing() { func sendPing() {
self.write("", withType: PacketType.PING, withData: nil) write("", withType: PacketType.PING, withData: nil)
} }
/// Send polling message. /// Send polling message.
@ -577,18 +572,18 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
doubleEncodeUTF8(&msg) doubleEncodeUTF8(&msg)
let strMsg = "\(type.rawValue)\(msg)" let strMsg = "\(type.rawValue)\(msg)"
self.postWait.append(strMsg) postWait.append(strMsg)
if datas != nil { if datas != nil {
for data in datas! { for data in datas! {
let (nilData, b64Data) = self.createBinaryDataForSend(data) let (nilData, b64Data) = createBinaryDataForSend(data)
self.postWait.append(b64Data!) postWait.append(b64Data!)
} }
} }
if !self.waitingForPost { if !waitingForPost {
self.flushWaitingForPost() flushWaitingForPost()
} }
} }
@ -598,13 +593,13 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
datas:ContiguousArray<NSData>? = nil) { datas:ContiguousArray<NSData>? = nil) {
SocketLogger.log("Sending ws: \(str) as type: \(type.rawValue)", client: self) SocketLogger.log("Sending ws: \(str) as type: \(type.rawValue)", client: self)
self.ws?.writeString("\(type.rawValue)\(str)") ws?.writeString("\(type.rawValue)\(str)")
if datas != nil { if datas != nil {
for data in datas! { for data in datas! {
let (data, nilString) = self.createBinaryDataForSend(data) let (data, nilString) = createBinaryDataForSend(data)
if data != nil { if data != nil {
self.ws?.writeData(data!) ws?.writeData(data!)
} }
} }
} }
@ -612,11 +607,11 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
// Starts the ping timer // Starts the ping timer
private func startPingTimer() { private func startPingTimer() {
if self.pingInterval == nil { if pingInterval == nil {
return return
} }
self.pingTimer?.invalidate() pingTimer?.invalidate()
dispatch_async(dispatch_get_main_queue()) {[weak self] in dispatch_async(dispatch_get_main_queue()) {[weak self] in
if let this = self { if let this = self {
this.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(this.pingInterval!), this.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(this.pingInterval!),
@ -627,17 +622,16 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
func stopPolling() { func stopPolling() {
self.session.invalidateAndCancel() session.invalidateAndCancel()
} }
private func upgradeTransport() { private func upgradeTransport() {
if self.websocketConnected { if websocketConnected {
SocketLogger.log("Upgrading transport to WebSockets", client: self) SocketLogger.log("Upgrading transport to WebSockets", client: self)
// Do a fast upgrade fastUpgrade = true
// At this point, we should not send anymore polling messages- sendPollMessage("", withType: PacketType.NOOP)
self.fastUpgrade = true // After this point, we should not send anymore polling messages
self.sendPollMessage("", withType: PacketType.NOOP)
} }
} }
@ -645,7 +639,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
Write a message, independent of transport. Write a message, independent of transport.
*/ */
public func write(msg:String, withType type:PacketType, withData data:ContiguousArray<NSData>?) { public func write(msg:String, withType type:PacketType, withData data:ContiguousArray<NSData>?) {
dispatch_async(self.emitQueue) {[weak self] in dispatch_async(emitQueue) {[weak self] in
if let this = self where this.connected { if let this = self where this.connected {
if this.websocket { if this.websocket {
SocketLogger.log("Writing ws: \(msg):\(data)", client: this) SocketLogger.log("Writing ws: \(msg):\(data)", client: this)
@ -671,56 +665,56 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
} }
} }
self.write(msg, withType: pType, withData: arr) write(msg, withType: pType, withData: arr)
} }
} }
// Delagate methods // Delagate methods
public func websocketDidConnect(socket:WebSocket) { public func websocketDidConnect(socket:WebSocket) {
self.websocketConnected = true websocketConnected = true
if !self.forceWebsockets { if !forceWebsockets {
self.probing = true probing = true
self.probeWebSocket() probeWebSocket()
} else { } else {
self._connected = true _connected = true
self.probing = false probing = false
self._polling = false _polling = false
} }
} }
public func websocketDidDisconnect(socket:WebSocket, error:NSError?) { public func websocketDidDisconnect(socket:WebSocket, error:NSError?) {
self.websocketConnected = false websocketConnected = false
self.probing = false probing = false
if self.closed { if closed {
self.client?.engineDidClose("Disconnect") client?.engineDidClose("Disconnect")
return return
} }
if self.websocket { if websocket {
self.pingTimer?.invalidate() pingTimer?.invalidate()
self._connected = false _connected = false
self._websocket = false _websocket = false
let reason = error?.localizedDescription ?? "Socket Disconnected" let reason = error?.localizedDescription ?? "Socket Disconnected"
if error != nil { if error != nil {
self.client?.didError(reason) client?.didError(reason)
} }
self.client?.engineDidClose(reason) client?.engineDidClose(reason)
} else { } else {
self.flushProbeWait() flushProbeWait()
} }
} }
public func websocketDidReceiveMessage(socket:WebSocket, text:String) { public func websocketDidReceiveMessage(socket:WebSocket, text:String) {
self.parseEngineMessage(text, fromPolling: false) parseEngineMessage(text, fromPolling: false)
} }
public func websocketDidReceiveData(socket:WebSocket, data:NSData) { public func websocketDidReceiveData(socket:WebSocket, data:NSData) {
self.parseEngineData(data) parseEngineData(data)
} }
} }

181
SocketIOClientSwift/SocketIOClient.swift
View File

@ -31,7 +31,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
private var _connecting = false private var _connecting = false
private var currentReconnectAttempt = 0 private var currentReconnectAttempt = 0
private var handlers = ContiguousArray<SocketEventHandler>() private var handlers = ContiguousArray<SocketEventHandler>()
private var params:[String: AnyObject]? private var connectParams:[String: AnyObject]?
private var _secure = false private var _secure = false
private var _sid:String? private var _sid:String?
private var _reconnecting = false private var _reconnecting = false
@ -50,27 +50,27 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
public let handleQueue = dispatch_queue_create("handleQueue", DISPATCH_QUEUE_SERIAL) public let handleQueue = dispatch_queue_create("handleQueue", DISPATCH_QUEUE_SERIAL)
public let emitQueue = dispatch_queue_create("emitQueue", DISPATCH_QUEUE_SERIAL) public let emitQueue = dispatch_queue_create("emitQueue", DISPATCH_QUEUE_SERIAL)
public var closed:Bool { public var closed:Bool {
return self._closed return _closed
} }
public var connected:Bool { public var connected:Bool {
return self._connected return _connected
} }
public var connecting:Bool { public var connecting:Bool {
return self._connecting return _connecting
} }
public var engine:SocketEngine? public var engine:SocketEngine?
public var nsp = "/" public var nsp = "/"
public var opts:[String: AnyObject]? public var opts:[String: AnyObject]?
public var reconnects = true public var reconnects = true
public var reconnecting:Bool { public var reconnecting:Bool {
return self._reconnecting return _reconnecting
} }
public var reconnectWait = 10 public var reconnectWait = 10
public var secure:Bool { public var secure:Bool {
return self._secure return _secure
} }
public var sid:String? { public var sid:String? {
return self._sid return _sid
} }
/** /**
@ -87,14 +87,13 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
self.socketURL = socketURL self.socketURL = socketURL
self.opts = opts self.opts = opts
// Set options // Set options
if let sessionDelegate = opts?["sessionDelegate"] as? NSURLSessionDelegate { if let sessionDelegate = opts?["sessionDelegate"] as? NSURLSessionDelegate {
self.sessionDelegate = sessionDelegate self.sessionDelegate = sessionDelegate
} }
if let connectParams = opts?["connectParams"] as? [String: AnyObject] { if let connectParams = opts?["connectParams"] as? [String: AnyObject] {
self.params = connectParams self.connectParams = connectParams
} }
if let log = opts?["log"] as? Bool { if let log = opts?["log"] as? Bool {
@ -137,7 +136,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
private func addEngine() { private func addEngine() {
SocketLogger.log("Adding engine", client: self) SocketLogger.log("Adding engine", client: self)
self.engine = SocketEngine(client: self, opts: self.opts) engine = SocketEngine(client: self, opts: opts)
} }
/** /**
@ -148,34 +147,34 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
public func close(#fast:Bool) { public func close(#fast:Bool) {
SocketLogger.log("Closing socket", client: self) SocketLogger.log("Closing socket", client: self)
self.reconnects = false reconnects = false
self._connecting = false _connecting = false
self._connected = false _connected = false
self._reconnecting = false _reconnecting = false
self.engine?.close(fast: fast) engine?.close(fast: fast)
self.engine = nil engine = nil
} }
/** /**
Connect to the server. Connect to the server.
*/ */
public func connect() { public func connect() {
self.connect(timeoutAfter: 0, withTimeoutHandler: nil) connect(timeoutAfter: 0, withTimeoutHandler: nil)
} }
/** /**
Connect to the server. If we aren't connected after timeoutAfter, call handler Connect to the server. If we aren't connected after timeoutAfter, call handler
*/ */
public func connect(#timeoutAfter:Int, withTimeoutHandler handler:(() -> Void)?) { public func connect(#timeoutAfter:Int, withTimeoutHandler handler:(() -> Void)?) {
if self.closed { if closed {
SocketLogger.log("Warning! This socket was previously closed. This might be dangerous!", client: self) SocketLogger.log("Warning! This socket was previously closed. This might be dangerous!", client: self)
self._closed = false _closed = false
} else if self.connected { } else if connected {
return return
} }
self.addEngine() addEngine()
self.engine?.open(opts: self.params) engine?.open(opts: connectParams)
if timeoutAfter == 0 { if timeoutAfter == 0 {
return return
@ -195,7 +194,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
} }
private func createOnAck(event:String, items:[AnyObject]) -> OnAckCallback { private func createOnAck(event:String, items:[AnyObject]) -> OnAckCallback {
return {[weak self, ack = ++self.currentAck] timeout, callback in return {[weak self, ack = ++currentAck] timeout, callback in
if let this = self { if let this = self {
this.ackHandlers.addAck(ack, callback: callback) this.ackHandlers.addAck(ack, callback: callback)
@ -217,43 +216,43 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
func didConnect() { func didConnect() {
SocketLogger.log("Socket connected", client: self) SocketLogger.log("Socket connected", client: self)
self._closed = false _closed = false
self._connected = true _connected = true
self._connecting = false _connecting = false
self._reconnecting = false _reconnecting = false
self.currentReconnectAttempt = 0 currentReconnectAttempt = 0
self.reconnectTimer?.invalidate() reconnectTimer?.invalidate()
self.reconnectTimer = nil reconnectTimer = nil
self._sid = self.engine?.sid _sid = engine?.sid
// Don't handle as internal because something crazy could happen where // Don't handle as internal because something crazy could happen where
// we disconnect before it's handled // we disconnect before it's handled
self.handleEvent("connect", data: nil, isInternalMessage: false) handleEvent("connect", data: nil, isInternalMessage: false)
} }
func didDisconnect(reason:String) { func didDisconnect(reason:String) {
if self.closed { if closed {
return return
} }
SocketLogger.log("Disconnected: \(reason)", client: self) SocketLogger.log("Disconnected: \(reason)", client: self)
self._closed = true _closed = true
self._connected = false _connected = false
self.reconnects = false reconnects = false
self._connecting = false _connecting = false
self._reconnecting = false _reconnecting = false
// Make sure the engine is actually dead. // Make sure the engine is actually dead.
self.engine?.close(fast: true) engine?.close(fast: true)
self.handleEvent("disconnect", data: [reason], isInternalMessage: true) handleEvent("disconnect", data: [reason], isInternalMessage: true)
} }
/// error /// error
public func didError(reason:AnyObject) { public func didError(reason:AnyObject) {
SocketLogger.err("Error: \(reason)", client: self) SocketLogger.err("Error: \(reason)", client: self)
self.handleEvent("error", data: reason as? [AnyObject] ?? [reason], handleEvent("error", data: reason as? [AnyObject] ?? [reason],
isInternalMessage: true) isInternalMessage: true)
} }
@ -261,18 +260,18 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
Same as close Same as close
*/ */
public func disconnect(#fast:Bool) { public func disconnect(#fast:Bool) {
self.close(fast: fast) close(fast: fast)
} }
/** /**
Send a message to the server Send a message to the server
*/ */
public func emit(event:String, _ items:AnyObject...) { public func emit(event:String, _ items:AnyObject...) {
if !self.connected { if !connected {
return return
} }
dispatch_async(self.emitQueue) {[weak self] in dispatch_async(emitQueue) {[weak self] in
self?._emit(event, items) self?._emit(event, items)
} }
} }
@ -281,11 +280,11 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
Same as emit, but meant for Objective-C Same as emit, but meant for Objective-C
*/ */
public func emit(event:String, withItems items:[AnyObject]) { public func emit(event:String, withItems items:[AnyObject]) {
if !self.connected { if !connected {
return return
} }
dispatch_async(self.emitQueue) {[weak self] in dispatch_async(emitQueue) {[weak self] in
self?._emit(event, items) self?._emit(event, items)
} }
} }
@ -295,30 +294,30 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
an ack. an ack.
*/ */
public func emitWithAck(event:String, _ items:AnyObject...) -> OnAckCallback { public func emitWithAck(event:String, _ items:AnyObject...) -> OnAckCallback {
if !self.connected { if !connected {
return createOnAck(event, items: items) return createOnAck(event, items: items)
} }
return self.createOnAck(event, items: items) return createOnAck(event, items: items)
} }
/** /**
Same as emitWithAck, but for Objective-C Same as emitWithAck, but for Objective-C
*/ */
public func emitWithAck(event:String, withItems items:[AnyObject]) -> OnAckCallback { public func emitWithAck(event:String, withItems items:[AnyObject]) -> OnAckCallback {
if !self.connected { if !connected {
return self.createOnAck(event, items: items) return createOnAck(event, items: items)
} }
return self.createOnAck(event, items: items) return createOnAck(event, items: items)
} }
private func _emit(event:String, _ args:[AnyObject], ack:Int? = nil) { private func _emit(event:String, _ args:[AnyObject], ack:Int? = nil) {
if !self.connected { if !connected {
return return
} }
let packet = SocketPacket(type: nil, data: args, nsp: self.nsp, id: ack) let packet = SocketPacket(type: nil, data: args, nsp: nsp, id: ack)
let str:String let str:String
SocketParser.parseForEmit(packet) SocketParser.parseForEmit(packet)
@ -327,15 +326,15 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
SocketLogger.log("Emitting: \(str)", client: self) SocketLogger.log("Emitting: \(str)", client: self)
if packet.type == SocketPacket.PacketType.BINARY_EVENT { if packet.type == SocketPacket.PacketType.BINARY_EVENT {
self.engine?.send(str, withData: packet.binary) engine?.send(str, withData: packet.binary)
} else { } else {
self.engine?.send(str, withData: nil) engine?.send(str, withData: nil)
} }
} }
// If the server wants to know that the client received data // If the server wants to know that the client received data
func emitAck(ack:Int, withData args:[AnyObject]) { func emitAck(ack:Int, withData args:[AnyObject]) {
dispatch_async(self.emitQueue) {[weak self] in dispatch_async(emitQueue) {[weak self] in
if let this = self where this.connected { if let this = self where this.connected {
let packet = SocketPacket(type: nil, data: args, nsp: this.nsp, id: ack) let packet = SocketPacket(type: nil, data: args, nsp: this.nsp, id: ack)
let str:String let str:String
@ -356,14 +355,14 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
} }
public func engineDidClose(reason:String) { public func engineDidClose(reason:String) {
self._connected = false _connected = false
self._connecting = false _connecting = false
if self.closed || !self.reconnects { if closed || !reconnects {
self.didDisconnect("Engine closed") didDisconnect("Engine closed")
} else if !self.reconnecting { } else if !reconnecting {
self.handleEvent("reconnect", data: [reason], isInternalMessage: true) handleEvent("reconnect", data: [reason], isInternalMessage: true)
self.tryReconnect() tryReconnect()
} }
} }
@ -371,7 +370,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
func handleAck(ack:Int, data:AnyObject?) { func handleAck(ack:Int, data:AnyObject?) {
SocketLogger.log("Handling ack: \(ack) with data: \(data)", client: self) SocketLogger.log("Handling ack: \(ack) with data: \(data)", client: self)
self.ackHandlers.executeAck(ack, ackHandlers.executeAck(ack,
items: (data as? [AnyObject]?) ?? (data != nil ? [data!] : nil)) items: (data as? [AnyObject]?) ?? (data != nil ? [data!] : nil))
} }
@ -381,19 +380,19 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
public func handleEvent(event:String, data:[AnyObject]?, isInternalMessage:Bool = false, public func handleEvent(event:String, data:[AnyObject]?, isInternalMessage:Bool = false,
wantsAck ack:Int? = nil) { wantsAck ack:Int? = nil) {
// println("Should do event: \(event) with data: \(data)") // println("Should do event: \(event) with data: \(data)")
if !self.connected && !isInternalMessage { if !connected && !isInternalMessage {
return return
} }
SocketLogger.log("Handling event: \(event) with data: \(data)", client: self) SocketLogger.log("Handling event: \(event) with data: \(data)", client: self)
if self.anyHandler != nil { if anyHandler != nil {
dispatch_async(dispatch_get_main_queue()) {[weak self] in dispatch_async(dispatch_get_main_queue()) {[weak self] in
self?.anyHandler?(SocketAnyEvent(event: event, items: data)) self?.anyHandler?(SocketAnyEvent(event: event, items: data))
} }
} }
for handler in self.handlers { for handler in handlers {
if handler.event == event { if handler.event == event {
if ack != nil { if ack != nil {
handler.executeCallback(data, withAck: ack!, withSocket: self) handler.executeCallback(data, withAck: ack!, withSocket: self)
@ -408,9 +407,9 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
Leaves nsp and goes back to / Leaves nsp and goes back to /
*/ */
public func leaveNamespace() { public func leaveNamespace() {
if self.nsp != "/" { if nsp != "/" {
self.engine?.send("1/\(self.nsp)", withData: nil) engine?.send("1/\(nsp)", withData: nil)
self.nsp = "/" nsp = "/"
} }
} }
@ -420,8 +419,8 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
public func joinNamespace() { public func joinNamespace() {
SocketLogger.log("Joining namespace", client: self) SocketLogger.log("Joining namespace", client: self)
if self.nsp != "/" { if nsp != "/" {
self.engine?.send("0/\(self.nsp)", withData: nil) engine?.send("0/\(nsp)", withData: nil)
} }
} }
@ -431,7 +430,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
public func off(event:String) { public func off(event:String) {
SocketLogger.log("Removing handler for event: \(event)", client: self) SocketLogger.log("Removing handler for event: \(event)", client: self)
self.handlers = self.handlers.filter {$0.event == event ? false : true} handlers = handlers.filter {$0.event == event ? false : true}
} }
/** /**
@ -441,21 +440,21 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
SocketLogger.log("Adding handler for event: \(name)", client: self) SocketLogger.log("Adding handler for event: \(name)", client: self)
let handler = SocketEventHandler(event: name, callback: callback) let handler = SocketEventHandler(event: name, callback: callback)
self.handlers.append(handler) handlers.append(handler)
} }
/** /**
Adds a handler that will be called on every event. Adds a handler that will be called on every event.
*/ */
public func onAny(handler:(SocketAnyEvent) -> Void) { public func onAny(handler:(SocketAnyEvent) -> Void) {
self.anyHandler = handler anyHandler = handler
} }
/** /**
Same as connect Same as connect
*/ */
public func open() { public func open() {
self.connect() connect()
} }
public func parseSocketMessage(msg:String) { public func parseSocketMessage(msg:String) {
@ -470,29 +469,29 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
Trieds to reconnect to the server. Trieds to reconnect to the server.
*/ */
public func reconnect() { public func reconnect() {
self._connected = false _connected = false
self._connecting = false _connecting = false
self._reconnecting = false _reconnecting = false
self.engine?.stopPolling() engine?.stopPolling()
self.tryReconnect() tryReconnect()
} }
// We lost connection and should attempt to reestablish // We lost connection and should attempt to reestablish
@objc private func tryReconnect() { @objc private func tryReconnect() {
if self.reconnectAttempts != -1 && self.currentReconnectAttempt + 1 > self.reconnectAttempts { if reconnectAttempts != -1 && currentReconnectAttempt + 1 > reconnectAttempts {
self.didDisconnect("Reconnect Failed") didDisconnect("Reconnect Failed")
return return
} else if self.connected { } else if connected {
self._connecting = false _connecting = false
self._reconnecting = false _reconnecting = false
return return
} }
if self.reconnectTimer == nil { if reconnectTimer == nil {
SocketLogger.log("Starting reconnect", client: self) SocketLogger.log("Starting reconnect", client: self)
self._reconnecting = true _reconnecting = true
dispatch_async(dispatch_get_main_queue()) {[weak self] in dispatch_async(dispatch_get_main_queue()) {[weak self] in
if let this = self { if let this = self {
@ -503,10 +502,10 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
} }
SocketLogger.log("Trying to reconnect", client: self) SocketLogger.log("Trying to reconnect", client: self)
self.handleEvent("reconnectAttempt", data: [self.reconnectAttempts - self.currentReconnectAttempt], handleEvent("reconnectAttempt", data: [reconnectAttempts - currentReconnectAttempt],
isInternalMessage: true) isInternalMessage: true)
self.currentReconnectAttempt++ currentReconnectAttempt++
self.connect() connect()
} }
} }

88
SocketIOClientSwift/SocketPacket.swift
View File

@ -32,10 +32,10 @@ final class SocketPacket: Printable {
var better = "SocketPacket {type: ~~0; data: ~~1; " + var better = "SocketPacket {type: ~~0; data: ~~1; " +
"id: ~~2; placeholders: ~~3;}" "id: ~~2; placeholders: ~~3;}"
better = better["~~0"] ~= (self.type != nil ? String(self.type!.rawValue) : "nil") better = better["~~0"] ~= (type != nil ? String(type!.rawValue) : "nil")
better = better["~~1"] ~= (self.data != nil ? "\(self.data!)" : "nil") better = better["~~1"] ~= (data != nil ? "\(data!)" : "nil")
better = better["~~2"] ~= (self.id != nil ? String(self.id!) : "nil") better = better["~~2"] ~= (id != nil ? String(id!) : "nil")
better = better["~~3"] ~= (self.placeholders != nil ? String(self.placeholders!) : "nil") better = better["~~3"] ~= (placeholders != nil ? String(placeholders!) : "nil")
return better return better
} }
@ -77,15 +77,15 @@ final class SocketPacket: Printable {
} }
func addData(data:NSData) -> Bool { func addData(data:NSData) -> Bool {
if self.placeholders == self.currentPlace { if placeholders == currentPlace {
return true return true
} }
self.binary.append(data) binary.append(data)
self.currentPlace++ currentPlace++
if self.placeholders == self.currentPlace { if placeholders == currentPlace {
self.currentPlace = 0 currentPlace = 0
return true return true
} else { } else {
return false return false
@ -95,77 +95,77 @@ final class SocketPacket: Printable {
func createMessageForEvent(event:String) -> String { func createMessageForEvent(event:String) -> String {
let message:String let message:String
if self.binary.count == 0 { if binary.count == 0 {
self.type = PacketType.EVENT type = PacketType.EVENT
if self.nsp == "/" { if nsp == "/" {
if self.id == nil { if id == nil {
message = "2[\"\(event)\"" message = "2[\"\(event)\""
} else { } else {
message = "2\(self.id!)[\"\(event)\"" message = "2\(id!)[\"\(event)\""
} }
} else { } else {
if self.id == nil { if id == nil {
message = "2/\(self.nsp),[\"\(event)\"" message = "2/\(nsp),[\"\(event)\""
} else { } else {
message = "2/\(self.nsp),\(self.id!)[\"\(event)\"" message = "2/\(nsp),\(id!)[\"\(event)\""
} }
} }
} else { } else {
self.type = PacketType.BINARY_EVENT type = PacketType.BINARY_EVENT
if self.nsp == "/" { if nsp == "/" {
if self.id == nil { if id == nil {
message = "5\(self.binary.count)-[\"\(event)\"" message = "5\(binary.count)-[\"\(event)\""
} else { } else {
message = "5\(self.binary.count)-\(self.id!)[\"\(event)\"" message = "5\(binary.count)-\(id!)[\"\(event)\""
} }
} else { } else {
if self.id == nil { if id == nil {
message = "5\(self.binary.count)-/\(self.nsp),[\"\(event)\"" message = "5\(binary.count)-/\(nsp),[\"\(event)\""
} else { } else {
message = "5\(self.binary.count)-/\(self.nsp),\(self.id!)[\"\(event)\"" message = "5\(binary.count)-/\(nsp),\(id!)[\"\(event)\""
} }
} }
} }
return self.completeMessage(message) return completeMessage(message)
} }
func createAck() -> String { func createAck() -> String {
var msg:String var msg:String
if self.binary.count == 0 { if binary.count == 0 {
self.type = PacketType.ACK type = PacketType.ACK
if nsp == "/" { if nsp == "/" {
msg = "3\(self.id!)[" msg = "3\(id!)["
} else { } else {
msg = "3/\(self.nsp),\(self.id!)[" msg = "3/\(nsp),\(id!)["
} }
} else { } else {
self.type = PacketType.BINARY_ACK type = PacketType.BINARY_ACK
if nsp == "/" { if nsp == "/" {
msg = "6\(self.binary.count)-\(self.id!)[" msg = "6\(binary.count)-\(id!)["
} else { } else {
msg = "6\(self.binary.count)-/\(self.nsp),\(self.id!)[" msg = "6\(binary.count)-/\(nsp),\(id!)["
} }
} }
return self.completeMessage(msg, ack: true) return completeMessage(msg, ack: true)
} }
private func completeMessage(var message:String, ack:Bool = false) -> String { private func completeMessage(var message:String, ack:Bool = false) -> String {
var err:NSError? var err:NSError?
if self.data == nil || self.data!.count == 0 { if data == nil || data!.count == 0 {
return message + "]" return message + "]"
} else if !ack { } else if !ack {
message += "," message += ","
} }
for arg in self.data! { for arg in data! {
if arg is NSDictionary || arg is [AnyObject] { if arg is NSDictionary || arg is [AnyObject] {
let jsonSend = NSJSONSerialization.dataWithJSONObject(arg, let jsonSend = NSJSONSerialization.dataWithJSONObject(arg,
options: NSJSONWritingOptions(0), error: &err) options: NSJSONWritingOptions(0), error: &err)
@ -189,23 +189,23 @@ final class SocketPacket: Printable {
} }
func fillInPlaceholders() { func fillInPlaceholders() {
var newArr = NSMutableArray(array: self.data!) var newArr = NSMutableArray(array: data!)
for i in 0..<self.data!.count { for i in 0..<data!.count {
if let str = self.data?[i] as? String, num = str["~~(\\d)"].groups() { if let str = data?[i] as? String, num = str["~~(\\d)"].groups() {
newArr[i] = self.binary[num[1].toInt()!] newArr[i] = binary[num[1].toInt()!]
} else if self.data?[i] is NSDictionary || self.data?[i] is NSArray { } else if data?[i] is NSDictionary || data?[i] is NSArray {
newArr[i] = self._fillInPlaceholders(self.data![i]) newArr[i] = _fillInPlaceholders(data![i])
} }
} }
self.data = newArr as [AnyObject] data = newArr as [AnyObject]
} }
private func _fillInPlaceholders(data:AnyObject) -> AnyObject { private func _fillInPlaceholders(data:AnyObject) -> AnyObject {
if let str = data as? String { if let str = data as? String {
if let num = str["~~(\\d)"].groups() { if let num = str["~~(\\d)"].groups() {
return self.binary[num[1].toInt()!] return binary[num[1].toInt()!]
} else { } else {
return str return str
} }