Wrapper MessagePack.swift

MessagePackWrapper.swift

import Foundation
import MessagePack

// used https://github.com/a2/MessagePack.swift

// MARK: - PackableI/F

protocol Packable {
    func toPackValue() -> MessagePackValue
    init?(packValue: MessagePackValue)
}

// MARK: - Define

struct Street: Packable, CustomStringConvertible {
    let name: String
    let distance: Int
    
    init(name: String, distance: Int) {
        self.name = name
        self.distance = distance
    }
    
    init?(packValue: MessagePackValue) {
        if let name = packValue[.String("name")]?.stringValue, distance = packValue[.String("distance")]?.integerValue {
            self.name = name
            self.distance = Int(distance)
        } else {
            return nil
        }
    }
    
    func toPackValue() -> MessagePackValue {
        return .Map([.String("name"): .String(name), .String("distance"): .Int(Int64(distance))])
    }
    
    var description: String {
        return "Street(name: \(name), distance: \(distance))"
    }
}

struct Town: Packable, CustomStringConvertible {
    let streets: [Street]
    
    init(streets: [Street]) {
        self.streets = streets
    }
    
    init?(packValue: MessagePackValue) {
        guard let streets = packValue[.String("streets")]?.arrayValue else { return nil }
        self.streets = streets.flatMap(Street.init)
    }
    
    func toPackValue() -> MessagePackValue {
        return .Map([.String("streets"): .Array(streets.map({ $0.toPackValue() }))])
    }
    
    var description: String {
        return "Town(streets: \(streets))"
    }
}

struct Address: Packable, CustomStringConvertible {
    let town: Town
    
    init(town: Town) {
        self.town = town
    }
    
    init?(packValue: MessagePackValue) {
        guard let town = packValue[.String("town")].flatMap(Town.init) else { return nil }
        self.town = town
    }
    
    func toPackValue() -> MessagePackValue {
        return .Map([.String("town"): town.toPackValue()])
    }
    
    var description: String {
        return "Address(town: \(town))"
    }
}

struct Company: Packable, CustomStringConvertible {
    let address: Address
    
    init(address: Address) {
        self.address = address
    }
    
    init?(packValue: MessagePackValue) {
        guard let address = packValue[.String("address")].flatMap(Address.init) else { return nil }
        self.address = address
    }

    func toPackValue() -> MessagePackValue {
        return .Map([.String("address"): address.toPackValue()])
    }
    
    var description: String {
        return "Company(address: \(address))"
    }
}

struct Employee: Packable, CustomStringConvertible {
    let company: Company
    
    init(company: Company) {
        self.company = company
    }
    
    init?(packValue: MessagePackValue) {
        guard let company = packValue[.String("company")].flatMap(Company.init) else { return nil }
        self.company = company
    }
    
    func toPackValue() -> MessagePackValue {
        return .Map([.String("company"): company.toPackValue()])
    }
    
    var description: String {
        return "Employee(company: \(company))"
    }
}

struct Manager: Packable, CustomStringConvertible {
    let name: String
    let employee: Employee
    
    init(name: String, employee: Employee) {
        self.name = name
        self.employee = employee
    }
    
    init?(packValue: MessagePackValue) {
        if let name = packValue[.String("name")]?.stringValue, employee = packValue[.String("employee")].flatMap(Employee.init) {
            self.name = name
            self.employee = employee
        } else {
            return nil
        }
    }
    
    func toPackValue() -> MessagePackValue {
        return .Map([.String("name"): .String(name), .String("employee"): employee.toPackValue()])
    }
    
    var description: String {
        return "Manager(name: \(name), employee: \(employee))"
    }
}

// MARK: - Play

let street1 = Street(name: "street1", distance: 1)
let street2 = Street(name: "street2", distance: 2)
let street3 = Street(name: "street2", distance: 3)
let town = Town(streets: [street1, street2, street3])
let address = Address(town: town)
let company = Company(address: address)
let employee = Employee(company: company)
let manager = Manager(name: "manager", employee: employee)

// serialize
let packed = pack(manager.toPackValue())

// deserialize
if let unpacked = try? unpack(packed) {
    let manager = Manager(packValue: unpacked)
    print(manager)
}