Andrew Bancroft

the secret

1
2
3
4
5
6
7
8

@Model
final class Item {
    var timestamp: Date

    init(timestamp: Date) {
        self.timestamp = timestamp
    }
}

1
2
3
4
5
6
7

do {
    let container = try ModelContainer(
        for: Item.self)
		//...more code to come
} catch {
    fatalError("Failed to create container")
}

1
2
3
4
5
6
7
8

do {
    let container = try ModelContainer(
        for: Item.self, ModelConfiguration(inMemory: true)
    )
		//...more code to come
} catch {
    fatalError("Failed to create container")
}

1
2
3
4
5

let items = [
    Item(timestamp: Date()),
    Item(timestamp: Date()),
	Item(timestamp: Date())
]

1
2
3

for item in items {
    container.mainContext.insert(object: item)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@MainActor
let appContainer: ModelContainer = {
    do {
        let container = try ModelContainer(for: Item.self)
        //...
				return container // this line wasn't in any of the examples above
    } catch {
        fatalError("Failed to create container")
    }
}() // The "()" here runs the closure immediately

1
2
3
4
5
6
7
8
9

@main
@MainActor
struct TrySwiftDataApp: App {    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@main
@MainActor
struct TrySwiftDataApp: App {    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(appContainer)
    }
}

1
2
3
4
5

// Make sure the persistent store is empty. If it's not, return the non-empty container.
var itemFetchDescriptor = FetchDescriptor<Item>()
itemFetchDescriptor.fetchLimit = 1

guard try container.mainContext.fetch(itemFetchDescriptor).count == 0 else { return container }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@MainActor
let appContainer: ModelContainer = {
    do {
        let container = try ModelContainer(for: Item.self)

        // Make sure the persistent store is empty. If it's not, return the non-empty container.
        var itemFetchDescriptor = FetchDescriptor<Item>()
        itemFetchDescriptor.fetchLimit = 1

        guard try container.mainContext.fetch(itemFetchDescriptor).count == 0 else { return container }

        // This code will only run if the persistent store is empty.
        let items = [
            Item(timestamp: Date()),
            Item(timestamp: Date()),
            Item(timestamp: Date())
        ]

        for item in items {
            container.mainContext.insert(object: item)
        }

        return container
    } catch {
        fatalError("Failed to create container")
    }
}()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

@MainActor
let previewContainer: ModelContainer = {
    do {
        let container = try ModelContainer(
            for: Item.self, ModelConfiguration(inMemory: true)
        )

        let items = [
            Item(timestamp: Date()),
            Item(timestamp: Date()),
            Item(timestamp: Date())
        ]

        for item in items {
            container.mainContext.insert(object: item)
        }

        return container
    } catch {
        fatalError("Failed to create container")
    }
}()

1
2
3
4

#Preview {
    ContentView()
        .modelContainer(previewContainer)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

struct ContentView_Previews: PreviewProvider {
    static let previewContainer: ModelContainer = {
        do {
            let container = try ModelContainer(
                for: Item.self, ModelConfiguration(inMemory: true)
            )

            let items = [
                Item(timestamp: Date()),
                Item(timestamp: Date()),
                Item(timestamp: Date())
            ]

            for item in items {
                container.mainContext.insert(object: item)
            }

            return container
        } catch {
            fatalError("Failed to create container")
        }
    }()

    static var previews: some View {
        ContentView()
            .modelContainer(previewContainer)
    }
}

1
2

@MainActor
final class TrySwiftDataTests: XCTestCase { ... }

1

var testContainer: ModelContainer?

override func setUpWithError() throws {
// Put setup code here. This method is called before the invocation of each test method in the class.

    self.testContainer = {
        do {
            let container = try ModelContainer(
                for: Item.self, ModelConfiguration(inMemory: true)
            )

            let items = [
                Item(timestamp: Date()),
                Item(timestamp: Date()),
                Item(timestamp: Date())
            ]

            for item in items {
                container.mainContext.insert(object: item)
            }

            return container
        } catch {
            fatalError("Failed to create container")
        }
    }()
}

1
2
3
4
5
6
7

func testExample() throws {        
    let fetchDescriptor = FetchDescriptor<Item>()

    let result = try testContainer?.mainContext.fetch(fetchDescriptor)

    XCTAssertEqual(result?.count, 3)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import Foundation
import SwiftData

@Model
final class Item {
    var timestamp: Date

    init(timestamp: Date) {
        self.timestamp = timestamp
    }
} 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import SwiftUI
import SwiftData

@main
struct TrySwiftDataApp: App {

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: Item.self)
    }
}
1
2
3
4
5
6
7
8

...
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: [ModelClass1.self, ModelClass2.self])
    }
...
1
2
3
4
5
6
7
8

@Model
final class Item {
    var timestamp: Date

    init(timestamp: Date) {
        self.timestamp = timestamp
    }
} 
1

@Query private var items: [Item]
1
2
3

List(items) { item in
    Text("Item at \(item.timestamp)")
}
1
2
3
4
5
6
7
8

@Model
final class Item {
    var timestamp: Date

    init(timestamp: Date) {
        self.timestamp = timestamp
    }
} 
1

@Environment(\.modelContext) private var modelContext
1
2

let newItem = Item(timestamp: Date())
modelContext.insert(newItem)
1
2
3

for index in offsets {
    modelContext.delete(items[index])
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import Foundation
import CoreData

// ❇️ BlogIdea code generation is turned OFF in the xcdatamodeld file
public class BlogIdea: NSManagedObject, Identifiable {
    @NSManaged public var ideaTitle: String?
    @NSManaged public var ideaDescription: String?
}

extension BlogIdea {
    // ❇️ The @FetchRequest property wrapper in the ContentView will call this function
    static func allIdeasFetchRequest() -> NSFetchRequest<BlogIdea> {
        let request: NSFetchRequest<BlogIdea> = BlogIdea.fetchRequest() as! NSFetchRequest<BlogIdea>

        // ❇️ The @FetchRequest property wrapper in the ContentView requires a sort descriptor
        request.sortDescriptors = [NSSortDescriptor(key: "ideaTitle", ascending: true)]

        return request
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import SwiftUI

struct SwiftUIView: View {
    // ❇️ The BlogIdea class has an `allIdeasFetchRequest` static function that can be used here
    @FetchRequest(fetchRequest: BlogIdea.allIdeasFetchRequest()) var blogIdeas: FetchedResults<BlogIdea>

    var body: some View {
        List(self.blogIdeas) { blogIdea in
            Text(blogIdea.ideaTitle ?? "")
        }
    }
}
 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 

class="lnt"> 1 language-swift" data-lang="swift">func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) { if let windowScene = scene as? UIWindowScene { let window = UIWindow(windowScene: windowScene)

// ❇️ Get the managedObjectContext from the persistent container // ❇️ This assumes you've left the Core Data stack creation code within AppDelegate let managedObjectContext = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext

// ❇️ Pass it to the ContentView through the  // ❇️ managedObjectContext @Environment variable let contentView = ContentView() .environment(\.managedObjectContext, managedObjectContext)

window.rootViewController = UIHostingController(rootView: contentView)

self.window = window window.makeKeyAndVisible() } class="p">}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import SwiftUI

struct SwiftUIView: View {
    // ❇️ Access the @Environment's managedObjectContext variable
    // ❇️ and keep a reference to use later
    @Environment(\.managedObjectContext) var managedObjectContext

    var body: some View {
        // ❇️ Use self.managedObjectContext however you need within your SwiftUI view!
    }
}
1#!/bin/bash
2
3hugo
4
5git add .
6
7git commit -m "Updates"
8
9git push

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func validateAge(value: AutoreleasingUnsafeMutablePointer<AnyObject?>) throws {
    guard let valueNumber = value.pointee as? NSNumber else { return }

    if valueNumber.floatValue > 0.0 {
        return
    }

    let errorStr = NSLocalizedString("Age must be greater than zero", tableName: "Employee", comment: "validation: zero age error")
    let userInfoDict = [NSLocalizedDescriptionKey: errorStr]
    let error = NSError(domain: "EMPLOYEE_ERROR_DOMAIN", code: 1123, userInfo: userInfoDict)
    throw error
}
1
2
3

  @nonobjc public class func fetchRequest() -> NSFetchRequest<EntityName> {
      return NSFetchRequest<EntityName>(entityName: "EntityName")
  }
1
2
3

extension EntityName {
    static let entityName = "EntityName"
}
1
2
3
4
5
6

public class BlogIdea: NSManagedObject {

    @NSManaged public var ideaTitle: String?
    @NSManaged public var ideaDescription: String?

}
1
2
3

class BlogIdeaProvider {
    // fetches BlogIdea instances to use in your view controller
}
1class BlogIdeaProvider {
2    func fetchBlogIdeas() -> [BlogIdea] {
3        // fetch BlogIdea instances
4
5        // return the BlogIdea NSManagedObject subclass for the view controller to use
6    }
7}
1class BlogIdeaProvider {
2    func fetchBlogIdeaTitles() -> [String] {
3        // fetch BlogIdea instances
4
5        // pull out ONLY the ideaTitle, 
6        // assemble an array for the titles, 
7        // return the array
8    }
9}
 1// MARK: - Concept
 2// If you give a `Provider` a persistent container, and a fetched results controller delegate to talk back to,
 3// a `Provider` Type can act as a liaison between the view controller and the pieces of Core Data that are needed
 4// to initialize a fetched results controller, perform fetches, and other Core Data related actions on behalf of your
 5// view controller (instead of you putting all this code in the view controller itself)...
 6
 7class BlogIdeaProvider {
 8    private var persistentContainer: NSPersistentContainer
 9    private weak var fetchedResultsControllerDelegate: NSFetchedResultsControllerDelegate?
10    
11    // MARK: - Initializers
12    init(with persistentContainer: NSPersistentContainer, 
13              fetchedResultsControllerDelegate: NSFetchedResultsControllerDelegate?) {
14
15        self.persistentContainer = persistentContainer
16        self.fetchedResultsControllerDelegate = fetchedResultsControllerDelegate
17
18    }
19    
20    // use this in your view controller to display BlogIdea instances
21    lazy var fetchedResultsController : NSFetchedResultsController<BlogIdea> = {
22        // Configure a fetched results controller and perform an initial fetch
23        let blogIdeasFetchRequest = NSFetchRequest<BlogIdea>(entityName: "BlogIdea")
24        
25        let controller = NSFetchedResultsController<BlogIdea>(  fetchRequest: blogIdeasFetchRequest,
26                                                                managedObjectContext: self.persistentContainer.viewContext,
27                                                                sectionNameKeyPath: nil,
28                                                                cacheName: nil)
29        
30        controller.delegate = self.fetchedResultsControllerDelegate
31        
32        do {
33            try controller.performFetch()
34        } catch {
35            fatalError("\(#function): Failed to performFetch: \(error)")
36        }
37        
38        return controller
39    }()
40}
 1import UIKit
 2import PlaygroundSupport
 3import SwiftUI
 4
 5// Make a SwiftUI view
 6struct ContentView: View {
 7    var body: some View {
 8        Text("SwiftUI in a Playground!")
 9    }
10}
11
12// Make a UIHostingController
13let viewController = UIHostingController(rootView: ContentView())
14
15// Assign it to the playground's liveView
16PlaygroundPage.current.liveView = viewController
17
18// RUN!
1
2
3
4
5
6
7

public class BlogIdea: NSManagedObject {

    @NSManaged public var ideaTitle: String?
    @NSManaged public var ideaDescription: String?

    static var entityName: String { return "BlogIdea" }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class MainViewController:   UIViewController, 
                            NSFetchedResultsControllerDelegate, 
                            UITableViewDataSource, 
                            UITableViewDelegate {
    // Responsible for listing out BlogIdeas in a table view

    // Holds a reference to an NSManagedObjectContext instance
    // which gets initialized in the SceneDelegate.swift file
    // and passed to this view controller when the scene gets "connected"

    // Uses NSFetchedResultsController to keep the table view in sync
    // with the Core Data managed object context

    // Implements swipe-to-delete with delete confirmation

    // Navigates to editor when someone taps on a table view row
    // and passes its NSManagedObjectContext instance along
}
1
2
3
4
5
6
7
8

class BlogIdeaEditorViewController: UIViewController {
    // Responsible for creating new BlogIdeas

    // Holds a reference to an NSManagedObjectContext instance
    // which gets passed along in MainViewController's prepare for segue method

    // Able to edit existing BlogIdeas
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
    // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
    guard let _ = (scene as? UIWindowScene) else { return }

    let navigationController = self.window?.rootViewController as! UINavigationController
    let mainVC = navigationController.viewControllers[0] as! MainViewController

    let viewContext = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
    viewContext.automaticallyMergesChangesFromParent = true

    mainVC.managedObjectContext = viewContext
}
1    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
2        // Override point for customization after application launch.
3        let rootVC = window?.rootViewController
4
5        return true
6    }
 1class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 2
 3    var window: UIWindow?
 4
 5
 6    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
 7        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
 8        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
 9        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
10        guard let _ = (scene as? UIWindowScene) else { return }
11        
12        let rootVC = self.window?.rootViewController 
13    }
14
15    // ... the rest of SceneDelegate
16}
 1lazy var persistentContainer: NSPersistentCloudKitContainer = {
 2        let container = NSPersistentCloudKitContainer(name: "NSPersistentCloudKitContainer_First_Steps")
 3        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
 4            if let error = error as NSError? {
 5                // Replace this implementation with code to handle the error appropriately.
 6                fatalError("Unresolved error \(error), \(error.userInfo)")
 7            }
 8        })
 9        return container
10    }()
1struct ContentView: View {
2    var body: some View {
3        // This is where you describe the view's content, layout, and behavior
4    }
5}

1struct ContentView_Previews : PreviewProvider {
2    static var previews: some View {
3        ContentView()
4    }
5}

1struct ContentView: View {
2    var body: some View {
3        // This is where you describe the view's content, layout, and behavior
4    }
5}

 1struct ContentView : View {
 2    var body: some View {
 3        VStack(alignment: .leading, spacing: nil) {
 4            Text("Turtle Rock")
 5                .font(.title)
 6            
 7            HStack{
 8                Text("Joshua Tree National Park")
 9                    .font(.subheadline)
10                
11                Spacer() // Make the horizontal stack use up all the horizontal space of the parent VStack
12                
13                Text("California")
14                    .font(.subheadline)
15            }
16        }
17    }
18}

 1import UIKit
 2import PlaygroundSupport
 3
 4class MyViewController : UIViewController {
 5    
 6    var currencyLabel = UILabel()
 7    override func loadView() {
 8        let view = UIView()
 9        view.backgroundColor = .white
10
11        currencyLabel.frame = CGRect(x: 150, y: 200, width: 200, height: 20)
12        currencyLabel.text = "$0.00"
13        currencyLabel.textColor = .black
14        
15        view.addSubview(currencyLabel)
16        self.view = view
17    }
18}
19
20let viewController = MyViewController()
21PlaygroundPage.current.liveView = viewController

1let currentTotalString = viewController.currencyLabel.text?.replacingOccurrences(of: "$", with: "", options: String.CompareOptions.literal, range: nil)
2
3var currentTotal = NSDecimalNumber(string: currentTotalString)

1let randomRange = Range<Double>(uncheckedBounds: (0.0,5.0))
2let randomAmount = Double.random(in: randomRange)
3let amountToAdd = NSDecimalNumber(floatLiteral: randomAmount)

1currentTotal = currentTotal.adding(amountToAdd)

1let currencyFormatter = NumberFormatter()
2currencyFormatter.locale = Locale.current
3currencyFormatter.usesGroupingSeparator = true
4currencyFormatter.numberStyle = NumberFormatter.Style.currency
5
6viewController.currencyLabel.text = currencyFormatter.string(from: currentTotal)

1# Read the CSV file
2car.sales <- read.csv("Car Sales.csv")
3
4# Show the first 5 rows
5head(car.sales, 5)

1# Make sure to use "\" slashes and not "/" slashes (it's a Windows thing)
2# There actually needs to be folders named "Path" and "To" and "CSV" and "File"
3# in your home directory (the "~" means "home directory") for this cell to work
4csv.file.path = normalizePath("~\\Path\\To\\CSV\\File\\Car Sales.csv", winslash = "\\")
5
6other.path.car.sales <- read.csv(csv.file.path)
7
8# Show the first 5 rows
9head(other.path.car.sales, 5)

1# Note the URL Encoding with "%20" for spaces
2url.to.csv.file <- "/datasets/Car%20Sales.csv"
3
4# Read the CSV file
5url.car.sales = read.(url_to_csv_file)
6
7# Show the first 5 rows
8head(url.car.sales, 5)

Error in read.table(file = file, header = header, sep = sep, quote = quote, : object 'url_to_csv_file' not found
Traceback:

1. read.csv2(url_to_csv_file)

2. read.table(file = file, header = header, sep = sep, quote = quote, 
 .     dec = dec, fill = fill, comment.char = comment.char, ...)

1import pandas as pd

1# Read the CSV file
2# This assumes "Car Sales.csv" is in the same directory as your notebook
3car_sales_data = pd.read_csv("Car Sales.csv")
4
5# Show the first 5 rows
6first_five = car_sales_data.head(5)
7display(first_five)

1first_five[['RedCars', 'SilverCars', 'BlackCars', 'BlueCars']].mean(axis=0)

RedCars       584.0
SilverCars    660.8
BlackCars     643.6
BlueCars      566.4
dtype: float64

1first_five[['RedCars', 'SilverCars', 'BlackCars', 'BlueCars']].mean(axis=1)

0    774.5
1    549.0
2    529.0
3    749.5
4    466.5
dtype: float64

1import pandas as pd

1# Read the Excel file
2car_sales_data = pd.read_excel("Car Sales.xlsx")
3
4# Show the first 5 rows
5car_sales_data.head(5)

1from os.path import expanduser as ospath
2
3user_home_directory = ospath("~")

1# Make sure to use "/" slashes and not "\" slashes
2# There actually needs to be folders named "Path" and "To" and "Excel" and "File"
3# in your home directory (the "~" means "home directory") for this cell to work
4excel_file_path = user_home_directory + "/Path/To/Excel/File/Car Sales.xlsx"
5
6other_path_car_sales_data = pd.read_excel(excel_file_path)
7
8# Show the first 5 rows
9other_path_car_sales_data.head(5)

1# Note the URL Encoding with "%20" for spaces
2url_to_excel_file = "/datasets/Car%20Sales.xlsx"
3
4# Read the Excel file
5url_car_sales_data = pd.read_excel(url_to_excel_file)
6
7# Show the first 5 rows
8url_car_sales_data.head(5)

1import pandas as pd

1# Read the CSV file
2car_sales_data = pd.read_csv("Car Sales.csv")
3
4# Show the first 5 rows
5car_sales_data.head(5)

1from os.path import expanduser as ospath
2
3user_home_directory = ospath("~")

1# Make sure to use "/" slashes and not "\" slashes
2# There actually needs to be folders named "Path" and "To" and "CSV" and "File"
3# in your home directory (the "~" means "home directory") for this cell to work
4csv_file_path = user_home_directory + "/Path/To/CSV/File/Car Sales.csv"
5
6other_path_car_sales_data = pd.read_csv(csv_file_path)
7
8# Show the first 5 rows
9other_path_car_sales_data.head(5)

1# Note the URL Encoding with "%20" for spaces
2url_to_csv_file = "/datasets/Car%20Sales.csv"
3
4# Read the CSV file
5url_car_sales_data = pd.read_csv(url_to_csv_file)
6
7# Show the first 5 rows
8url_car_sales_data.head(5)

 1import-module SqlServer
 2
 3$storageAccount = "<StorageAccountName>"  #replace this with your Azure storage account name
 4$storageKey = "<StorageAccountKey>"  #replace this with one of your Azure storage account keys
 5$secureString = convertto-securestring $storageKey  -asplaintext -force  
 6$credentialName = "BlobStorageCredential" #give the credential a name - you'll reference it again later (in other scripts, for example)
 7
 8cd SQLServer:\SQL\$env:COMPUTERNAME
 9
10$instances = Get-ChildItem
11$instances | new-sqlcredential -Name $credentialName -Identity $storageAccount -Secret $secureString
1const { EventHubClient, EventPosition } = require('@azure/event-hubs');
2const client = EventHubClient.createFromConnectionString(process.env["EVENTHUB_CONNECTION_STRING"], process.env["EVENTHUB_NAME"]);

1function main() {
2    const incorrectDataFormat = { DeviceID: "SomeDeviceID", LocationID: "SomeLocationID", Measurement: "SomeMeasurement" };
3    const CORRECTDataFormat = { body: { DeviceID: "SomeDeviceID", LocationID: "SomeLocationID", Measurement: "SomeMeasurement" } };
4    
5    client.send(incorrectDataFormat); // won't get picked up by Stream Analytics
6    client.send(CORRECTDataFormat); // WILL get picked up by Stream Analytics
7}

1Login-AzureRmAccount

 1###From Earlier###
 2
 3# Log in to Azure
 4
 5##New Stuff##
 6$resourceGroupName = "nameOfResourceGroup" # Choose a name that represents what the group contains
 7$location = "South Central US"
 8
 9# If you're not sure what the valid location names are, uncomment and run the line below.
10# Get-AzureRmLocation | Format-Table # Use the DisplayName value in $location above.
11
12New-AzureRmResourceGroup -Name $resourceGroupName -Location $location

 1###From Earlier###
 2
 3# Log in to Azure
 4
 5# Create Resource Group
 6
 7###New Stuff###
 8$storageAccountName = "$resourceGroupName" # You can choose any name you want - I name mine the same as my resource group for convenience
 9$containerName = "hdp$resourceGroupName" # I like to add "hdp" to the beginning of the resource group name
10
11Write-Host "Creating storage account..."
12New-AzureRmStorageAccount 
13  -Name $storageAccountName `
14  -ResourceGroupName $resourceGroupName `
15  -Type Standard_GRS ` # Options are Premium_LRS, Standard_GRS, Standard_LRS, Standard_RAGRS, and Standard_ZRS
16  -Location $location
17 
18Write-Host "Creating container..."
19$storageAccountKey = (Get-AzureRmStorageAccountKey -ResourceGroupName $resourceGroupName -Name $storageAccountName).Value[0]
20$context = New-AzureStorageContext -StorageAccountName $storageAccountName -StorageAccountKey $storageAccountKey
21New-AzureStorageContainer -Name $containerName -Context $context

 1###From Earlier###
 2
 3# Log in to Azure
 4
 5# Create Resource Group
 6
 7# Create Storage
 8
 9###New Stuff###
10Write-Host "Creating HDInsight cluster..."
11$httpCredential = New-Object System.Management.Automation.PSCredential ($httpUserName, $password)
12$sshCredential = New-Object System.Management.Automation.PSCredential ($sshUserName, $password)
13
14New-AzureRmHDInsightCluster 
15  -ClusterName $clusterName `
16  -ClusterType Hadoop `
17  -Version 3.6 `
18  -ClusterSizeInNodes 2 ` # You may need more... 2 is good for practicing
19  -OSType Linux `
20  -HttpCredential $httpCredential `
21  -SshCredential $sshCredential
22  -ResourceGroupName $resourceGroupName `
23  -Location $location `
24  -DefaultStorageAccountName "$storageAccountName.blob.core.windows.net" `
25  -DefaultStorageAccountKey $storageAccountKey `
26  -DefaultStorageContainer $containerName `
27 
28Write-Host "Finished!"

 1Login-AzureRmAccount
 2
 3$resourceGroupName = "nameOfResourceGroup"
 4$location = "South Central US"
 5$storageAccountName = "$resourceGroupName"
 6$containerName = "hdp$resourceGroupName"
 7$clusterName = $containerName
 8$clusterNodes = 2
 9$httpUserName = "HDUser"
10$sshUserName = "SSHHuser"
11$password = ConvertTo-SecureString "MyPa`$`$w0rD" -AsPlainText -Force
12
13Write-Host "Creating resource group..."
14New-AzureRmResourceGroup -Name $resourceGroupName -Location $location
15 
16Write-Host "Creating storage account..."
17New-AzureRmStorageAccount 
18  -Name $storageAccountName `
19  -ResourceGroupName $resourceGroupName `
20  -Type Standard_GRS `
21  -Location $location
22 
23Write-Host "Creating container..."
24$storageAccountKey = (Get-AzureRmStorageAccountKey -ResourceGroupName $resourceGroupName -Name $storageAccountName).Value[0]
25$context = New-AzureStorageContext -StorageAccountName $storageAccountName -StorageAccountKey $storageAccountKey
26New-AzureStorageContainer -Name $containerName -Context $context
27 
28Write-Host "Creating HDInsight Hadoop cluster..."
29$httpCredential = New-Object System.Management.Automation.PSCredential ($httpUserName, $password)
30$sshCredential = New-Object System.Management.Automation.PSCredential ($sshUserName, $password)
31
32New-AzureRmHDInsightCluster 
33  -ClusterName $clusterName `
34  -ClusterType Hadoop `
35  -Version 3.6 `
36  -ClusterSizeInNodes $clusterNodes ` # You may need more... 2 is good for practicing
37  -OSType Linux `
38  -HttpCredential $httpCredential `
39  -SshCredential $sshCredential
40  -ResourceGroupName $resourceGroupName `
41  -Location $location `
42  -DefaultStorageAccountName "$storageAccountName.blob.core.windows.net" `
43  -DefaultStorageAccountKey $storageAccountKey `
44  -DefaultStorageContainer $containerName `
45 
46Write-Host "Finished!"

 1class NameOfViewController: UIViewController, CLLocationManagerDelegate {
 2    private let locationManager = CLLocationManager()
 3
 4    // This will get updated via the location manager delegate's didUpdateLocations method
 5    var currentLocation: CLLocation? = nil 
 6
 7    override func viewDidLoad() {
 8        super.viewDidLoad()
 9        
10        // Do any additional setup after loading the view.
11
12        locationManager.delegate = self
13
14        self.startLocationServices() // This function is implemented below...
15    }
16}

 1// Monitor location services authorization changes
 2func locationManager(_ manager: CLLocationManager,
 3                        didChangeAuthorization status: CLAuthorizationStatus) {
 4    switch status {
 5    case .notDetermined: 
 6        break
 7    case .authorizedWhenInUse, .authorizedAlways:
 8        if CLLocationManager.locationServicesEnabled() {
 9            self.locationManager.startUpdatingLocation()
10        }
11    case .restricted, .denied: 
12        self.alertLocationAccessNeeded()
13    }
14
15// Get the device's current location and assign the latest CLLocation value to your tracking variable
16func locationManager(_ manager: CLLocationManager,
17                        didUpdateLocations locations: [CLLocation]) {
18    self.currentLocation = locations.last
19    }
20}

 1func startLocationServices() {
 2    locationManager.desiredAccuracy = kCLLocationAccuracyBest
 3    
 4    let locationAuthorizationStatus = CLLocationManager.authorizationStatus()
 5    
 6    switch locationAuthorizationStatus {
 7    case .notDetermined: 
 8        self.locationManager.requestWhenInUseAuthorization() // This is where you request permission to use location services
 9    case .authorizedWhenInUse, .authorizedAlways:
10        if CLLocationManager.locationServicesEnabled() {
11            self.locationManager.startUpdatingLocation()
12        }
13    case .restricted, .denied: 
14        self.alertLocationAccessNeeded()
15    }
16}

 1func alertLocationAccessNeeded() {
 2    let settingsAppURL = URL(string: UIApplicationOpenSettingsURLString)!
 3    
 4    let alert = UIAlertController(
 5        title: "Need Location Access",
 6        message: "Location access is required for including the location of the hazard.",
 7        preferredStyle: UIAlertControllerStyle.alert
 8    )
 9    
10    alert.addAction(UIAlertAction(title: "Cancel", style: .default, handler: nil))
11    alert.addAction(UIAlertAction(title: "Allow Location Access",
12                                    style: .cancel,
13                                    handler: { (alert) -> Void in
14                                    UIApplication.shared.open(settingsAppURL,
15                                                                options: [:],
16                                                                completionHandler: nil)
17    }))
18    
19    present(alert, animated: true, completion: nil)
20}

1let cameraAuthorizationStatus = AVCaptureDevice.authorizationStatus(for: .video)
2
3switch cameraAuthorizationStatus {
4case .notDetermined: requestCameraPermission()
5case .authorized: presentCamera()
6case .restricted, .denied: alertCameraAccessNeeded()
7}

1func requestCameraPermission() {
2    AVCaptureDevice.requestAccess(for: .video, completionHandler: {accessGranted in
3        guard accessGranted == true else { return }
4        self.presentCamera()
5    })
6}

1func presentCamera() {
2    let photoPicker = UIImagePickerController()
3    photoPicker.sourceType = .camera
4    photoPicker.delegate = self as? UIImagePickerControllerDelegate & UINavigationControllerDelegate
5    
6    self.present(photoPicker, animated: true, completion: nil)
7}

 1func alertCameraAccessNeeded() {
 2    let settingsAppURL = URL(string: UIApplicationOpenSettingsURLString)!
 3    
 4    let alert = UIAlertController(
 5        title: "Need Camera Access",
 6        message: "Camera access is required to make full use of this app.",
 7        preferredStyle: UIAlertControllerStyle.alert
 8    )
 9
10    alert.addAction(UIAlertAction(title: "Cancel", style: .default, handler: nil))
11    alert.addAction(UIAlertAction(title: "Allow Camera", style: .cancel, handler: { (alert) -> Void in
12        UIApplication.shared.open(settingsAppURL, options: [:], completionHandler: nil)
13    }))
14
15    present(alert, animated: true, completion: nil)
16}

1class NameOfViewController: UIViewController, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
2// ...
3}

1func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
2    let photo = info[UIImagePickerControllerOriginalImage] as! UIImage
3    // do something with the photo... set to UIImageView, save it, etc.
4
5    dismiss(animated: true, completion: nil)
6}

 1DECLARE @SearchString VARCHAR(255)
 2SET @SearchString = 'TextToFind'
 3
 4SELECT DISTINCT
 5	o.name AS ObjectName,
 6	o.type_desc as TypeDescription
 7FROM
 8	sys.sql_modules m
 9	INNER JOIN sys.objects o ON m.object_id = o.object_id
10WHERE
11	m.[definition] LIKE '%' + @SearchString + '%'
12ORDER BY
13	2, 1

 1DECLARE @SearchString VARCHAR(255)
 2SET @SearchString = 'TextToFind'
 3
 4SELECT
 5	OBJECT_NAME(id),
 6	*
 7FROM
 8	SYSCOMMENTS
 9WHERE
10	[text] LIKE '%' + @SearchString + '%'

1USE master;
2GO
3
4ALTER DATABASE [DatabaseName]
5SET SINGLE_USER
6WITH ROLLBACK IMMEDIATE;
7ALTER DATABASE [DatabaseName]
8SET MULTI_USER;
9GO

1USE master
2GO
3EXEC sp_who

1KILL [spid] -- do this for each spid returned by exec sp_who

1USE Master
2ALTER DATABASE DatabaseName SET MULTI_USER

1SELECT
2	request_session_id
3FROM
4	sys.dm_tran_locks
5WHERE
6	resource_database_id = DB_ID('DatabaseName')

1KILL [spid] -- do this for each spid returned by the previous query
2
3
4USE Master
5ALTER DATABASE YourDatabase SET MULTI_USER

1
2
3
4
5
6
7

fileprivate func validateHash(receipt: ParsedReceipt) throws {
    // Make sure that the ParsedReceipt instances has non-nil values needed for hash comparison

    // Compute the hash for your app & device

    // Compare the computed hash with the receipt's hash
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
    case emptyReceiptContents
    case receiptNotSigned
    case appleRootCertificateNotFound
    case receiptSignatureInvalid
    case malformedReceipt
    case malformedInAppPurchaseReceipt
    case incorrectHash
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fileprivate func validateHash(receipt: ParsedReceipt) throws {
    // Make sure that the ParsedReceipt instances has non-nil values needed for hash comparison
    guard let receiptOpaqueValueData = receipt.opaqueValue else { throw ReceiptValidationError.incorrectHash }
    guard let receiptBundleIdData = receipt.bundleIdData else { throw ReceiptValidationError.incorrectHash }
    guard let receiptHashData = receipt.sha1Hash else { throw ReceiptValidationError.incorrectHash }

    var deviceIdentifier = UIDevice.current.identifierForVendor?.uuid

    let rawDeviceIdentifierPointer = withUnsafePointer(to: &deviceIdentifier, {
        (unsafeDeviceIdentifierPointer: UnsafePointer<uuid_t?>) -> UnsafeRawPointer in
        return UnsafeRawPointer(unsafeDeviceIdentifierPointer)
    })

    let deviceIdentifierData = NSData(bytes: rawDeviceIdentifierPointer, length: 16)

    // Compute the hash for your app & device

    // Set up the hasing context
    var computedHash = Array<UInt8>(repeating: 0, count: 20)
    var sha1Context = SHA_CTX()

    SHA1_Init(&sha1Context)
    SHA1_Update(&sha1Context, deviceIdentifierData.bytes, deviceIdentifierData.length)
    SHA1_Update(&sha1Context, receiptOpaqueValueData.bytes, receiptOpaqueValueData.length)
    SHA1_Update(&sha1Context, receiptBundleIdData.bytes, receiptBundleIdData.length)
    SHA1_Final(&computedHash, &sha1Context)

    let computedHashData = NSData(bytes: &computedHash, length: 20)

    // Compare the computed hash with the receipt's hash
    guard computedHashData.isEqual(to: receiptHashData as Data) else { throw ReceiptValidationError.incorrectHash }
}
1
2
3

guard let receiptOpaqueValueData = receipt.opaqueValue else { throw ReceiptValidationError.incorrectHash }
guard let receiptBundleIdData = receipt.bundleIdData else { throw ReceiptValidationError.incorrectHash }
guard let receiptHashData = receipt.sha1Hash else { throw ReceiptValidationError.incorrectHash }
1
2
3
4
5
6
7
8

var deviceIdentifier = UIDevice.current.identifierForVendor?.uuid

let rawDeviceIdentifierPointer = withUnsafePointer(to: &deviceIdentifier, {
    (unsafeDeviceIdentifierPointer: UnsafePointer<uuid_t?>) -> UnsafeRawPointer in
    return UnsafeRawPointer(unsafeDeviceIdentifierPointer)
})

let deviceIdentifierData = NSData(bytes: rawDeviceIdentifierPointer, length: 16)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

struct ReceiptValidator {
    let receiptLoader = ReceiptLoader()
    let receiptExtractor = ReceiptExtractor()
    let receiptSignatureValidator = ReceiptSignatureValidator()
    let receiptParser = ReceiptParser()

    func validateReceipt() -> ReceiptValidationResult {
        do {
            let receiptData = try receiptLoader.loadReceipt()
            let receiptContainer = try receiptExtractor.extractPKCS7Container(receiptData)

            try receiptSignatureValidator.checkSignaturePresence(receiptContainer)
            try receiptSignatureValidator.checkSignatureAuthenticity(receiptContainer)

            let parsedReceipt = try receiptParser.parse(receiptContainer)
            try validateHash(receipt: parsedReceipt)

            return .success(parsedReceipt)
        } catch {
            return .error(error as! ReceiptValidationError)
        }
    }

    fileprivate func validateHash(receipt: ParsedReceipt) throws {
        // Make sure that the ParsedReceipt instances has non-nil values needed for hash comparison
        guard let receiptOpaqueValueData = receipt.opaqueValue else { throw ReceiptValidationError.incorrectHash }
        guard let receiptBundleIdData = receipt.bundleIdData else { throw ReceiptValidationError.incorrectHash }
        guard let receiptHashData = receipt.sha1Hash else { throw ReceiptValidationError.incorrectHash }

        var deviceIdentifier = UIDevice.current.identifierForVendor?.uuid

        let rawDeviceIdentifierPointer = withUnsafePointer(to: &deviceIdentifier, {
            (unsafeDeviceIdentifierPointer: UnsafePointer<uuid_t?>) -> UnsafeRawPointer in
            return UnsafeRawPointer(unsafeDeviceIdentifierPointer)
        })

        let deviceIdentifierData = NSData(bytes: rawDeviceIdentifierPointer, length: 16)

        // Compute the hash for your app & device

        // Set up the hasing context
        var computedHash = Array<UInt8>(repeating: 0, count: 20)
        var sha1Context = SHA_CTX()

        SHA1_Init(&sha1Context)
        SHA1_Update(&sha1Context, deviceIdentifierData.bytes, deviceIdentifierData.length)
        SHA1_Update(&sha1Context, receiptOpaqueValueData.bytes, receiptOpaqueValueData.length)
        SHA1_Update(&sha1Context, receiptBundleIdData.bytes, receiptBundleIdData.length)
        SHA1_Final(&computedHash, &sha1Context)

        let computedHashData = NSData(bytes: &computedHash, length: 20)

        // Compare the computed hash with the receipt's hash
        guard computedHashData.isEqual(to: receiptHashData as Data) else { throw ReceiptValidationError.incorrectHash }
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct ParsedReceipt {
    let bundleIdentifier: String?
    let bundleIdData: NSData?
    let appVersion: String?
    let opaqueValue: NSData?
    let sha1Hash: NSData?
    let inAppPurchaseReceipts: [ParsedInAppPurchaseReceipt]?
    let originalAppVersion: String?
    let receiptCreationDate: Date?
    let expirationDate: Date?
}

struct ParsedInAppPurchaseReceipt {
    let quantity: Int?
    let productIdentifier: String?
    let transactionIdentifier: String?
    let originalTransactionIdentifier: String?
    let purchaseDate: Date?
    let originalPurchaseDate: Date?
    let subscriptionExpirationDate: Date?
    let cancellationDate: Date?
    let webOrderLineItemId: Int?
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

func DecodeASN1Integer(startOfInt intPointer: inout UnsafePointer<UInt8>?, length: Int) -> Int? {
    // These will be set by ASN1_get_object
    var type = Int32(0)
    var xclass = Int32(0)
    var intLength = 0

    ASN1_get_object(&intPointer, &intLength, &type, &xclass, length)

    guard type == V_ASN1_INTEGER else {
        return nil
    }

    let integer = c2i_ASN1_INTEGER(nil, &intPointer, intLength)
    let result = ASN1_INTEGER_get(integer)
    ASN1_INTEGER_free(integer)

    return result
}

func DecodeASN1String(startOfString stringPointer: inout UnsafePointer<UInt8>?, length: Int) -> String? {
    // These will be set by ASN1_get_object
    var type = Int32(0)
    var xclass = Int32(0)
    var stringLength = 0

    ASN1_get_object(&stringPointer, &stringLength, &type, &xclass, length)

    if type == V_ASN1_UTF8STRING {
        let mutableStringPointer = UnsafeMutableRawPointer(mutating: stringPointer!)
        return String(bytesNoCopy: mutableStringPointer, length: stringLength, encoding: String.Encoding.utf8, freeWhenDone: false)
    }

    if type == V_ASN1_IA5STRING {
        let mutableStringPointer = UnsafeMutableRawPointer(mutating: stringPointer!)
        return String(bytesNoCopy: mutableStringPointer, length: stringLength, encoding: String.Encoding.ascii, freeWhenDone: false)
    }

    return nil
}

func DecodeASN1Date(startOfDate datePointer: inout UnsafePointer<UInt8>?, length: Int) -> Date? {
    // Date formatter code from https://www.objc.io/issues/17-security/receipt-validation/#parsing-the-receipt
    let dateFormatter = DateFormatter()
    dateFormatter.locale = Locale(identifier: "en_US_POSIX")
    dateFormatter.dateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"
    dateFormatter.timeZone = TimeZone(secondsFromGMT: 0)

    if let dateString = DecodeASN1String(startOfString: &datePointer, length:length) {
        return dateFormatter.date(from: dateString)
    }

    return nil
}
1
2
3
4
5
6
7
8
9

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
    case emptyReceiptContents
    case receiptNotSigned
    case appleRootCertificateNotFound
    case receiptSignatureInvalid
    case malformedReceipt
    case malformedInAppPurchaseReceipt
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

struct ReceiptParser {
    func parse(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws -> ParsedReceipt {
        var bundleIdentifier: String?
        var bundleIdData: NSData?
        var appVersion: String?
        var opaqueValue: NSData?
        var sha1Hash: NSData?
        var inAppPurchaseReceipts = [ParsedInAppPurchaseReceipt]()
        var originalAppVersion: String?
        var receiptCreationDate: Date?
        var expirationDate: Date?

        // Parse the receipt, setting each variable

        return ParsedReceipt(bundleIdentifier: bundleIdentifier,
                             bundleIdData: bundleIdData,
                             appVersion: appVersion,
                             opaqueValue: opaqueValue,
                             sha1Hash: sha1Hash,
                             inAppPurchaseReceipts: inAppPurchaseReceipts,
                             originalAppVersion: originalAppVersion,
                             receiptCreationDate: receiptCreationDate,
                             expirationDate: expirationDate)
    }

    func parseInAppPurchaseReceipt(currentInAppPurchaseASN1PayloadLocation: inout UnsafePointer<UInt8>?, payloadLength: Int) throws -> ParsedInAppPurchaseReceipt {
        var quantity: Int?
        var productIdentifier: String?
        var transactionIdentifier: String?
        var originalTransactionIdentifier: String?
        var purchaseDate: Date?
        var originalPurchaseDate: Date?
        var subscriptionExpirationDate: Date?
        var cancellationDate: Date?
        var webOrderLineItemId: Int?

        // Parse the in-app purchase receipt, setting each variable

        return ParsedInAppPurchaseReceipt(quantity: quantity,
                                          productIdentifier: productIdentifier,
                                          transactionIdentifier: transactionIdentifier,
                                          originalTransactionIdentifier: originalTransactionIdentifier,
                                          purchaseDate: purchaseDate,
                                          originalPurchaseDate: originalPurchaseDate,
                                          subscriptionExpirationDate: subscriptionExpirationDate,
                                          cancellationDate: cancellationDate,
                                          webOrderLineItemId: webOrderLineItemId)
    }
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110

func parse(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws -> ParsedReceipt {
    var bundleIdentifier: String?
    var bundleIdData: NSData?
    var appVersion: String?
    var opaqueValue: NSData?
    var sha1Hash: NSData?
    var inAppPurchaseReceipts = [ParsedInAppPurchaseReceipt]()
    var originalAppVersion: String?
    var receiptCreationDate: Date?
    var expirationDate: Date?

    // Strategy Step 1: Preliminary structure checks

    // Must have data to work with
    guard let contents = PKCS7Container.pointee.d.sign.pointee.contents, let octets = contents.pointee.d.data else {
        throw ReceiptValidationError.malformedReceipt
    }

    // Determine the start and end of the receipt payload
    var currentASN1PayloadLocation = UnsafePointer(octets.pointee.data)
    let endOfPayload = currentASN1PayloadLocation!.advanced(by: Int(octets.pointee.length))

    var type = Int32(0)
    var xclass = Int32(0)
    var length = 0

    ASN1_get_object(&currentASN1PayloadLocation, &length, &type, &xclass,Int(octets.pointee.length))

    // Payload must be an ASN1 Set
    guard type == V_ASN1_SET else {
        throw ReceiptValidationError.malformedReceipt
    }

    // Decode Payload
    // Strategy Step 2: Walk through payload (ASN1 Set) and parse each ASN1 Sequence 
    // within (ASN1 Sets contain one or more ASN1 Sequences)
    while currentASN1PayloadLocation! < endOfPayload {

        // Get next ASN1 Sequence
        ASN1_get_object(&#038;currentASN1PayloadLocation, &#038;length, &#038;type, &#038;xclass, currentASN1PayloadLocation!.distance(to: endOfPayload))

        // ASN1 Object type must be an ASN1 Sequence
        guard type == V_ASN1_SEQUENCE else {
            throw ReceiptValidationError.malformedReceipt
        }

        // Attribute type of ASN1 Sequence must be an Integer
        guard let attributeType = DecodeASN1Integer(startOfInt: &#038;currentASN1PayloadLocation, length: currentASN1PayloadLocation!.distance(to: endOfPayload)) else {
            throw ReceiptValidationError.malformedReceipt
        }

        // Attribute version of ASN1 Sequence must be an Integer
        guard DecodeASN1Integer(startOfInt: &#038;currentASN1PayloadLocation, length: currentASN1PayloadLocation!.distance(to: endOfPayload)) != nil else {
            throw ReceiptValidationError.malformedReceipt
        }

        // Get ASN1 Sequence value
        ASN1_get_object(&#038;currentASN1PayloadLocation, &#038;length, &#038;type, &#038;xclass, currentASN1PayloadLocation!.distance(to: endOfPayload))

        // ASN1 Sequence value must be an ASN1 Octet String
        guard type == V_ASN1_OCTET_STRING else {
            throw ReceiptValidationError.malformedReceipt
        }

        // Strategy Step 3: Decode attributes
        switch attributeType {
        case 2:
            var startOfBundleId = currentASN1PayloadLocation
            bundleIdData = NSData(bytes: startOfBundleId, length: length)
            bundleIdentifier = DecodeASN1String(startOfString: &#038;startOfBundleId, length: length)
        case 3:
            var startOfAppVersion = currentASN1PayloadLocation
            appVersion = DecodeASN1String(startOfString: &#038;startOfAppVersion, length: length)
        case 4:
            let startOfOpaqueValue = currentASN1PayloadLocation
            opaqueValue = NSData(bytes: startOfOpaqueValue, length: length)
        case 5:
            let startOfSha1Hash = currentASN1PayloadLocation
            sha1Hash = NSData(bytes: startOfSha1Hash, length: length)
        case 17:
            var startOfInAppPurchaseReceipt = currentASN1PayloadLocation
            let iapReceipt = try parseInAppPurchaseReceipt(currentInAppPurchaseASN1PayloadLocation: &#038;startOfInAppPurchaseReceipt, payloadLength: length)
            inAppPurchaseReceipts.append(iapReceipt)
        case 12:
            var startOfReceiptCreationDate = currentASN1PayloadLocation
            receiptCreationDate = DecodeASN1Date(startOfDate: &#038;startOfReceiptCreationDate, length: length)
        case 19:
            var startOfOriginalAppVersion = currentASN1PayloadLocation
            originalAppVersion = DecodeASN1String(startOfString: &#038;startOfOriginalAppVersion, length: length)
        case 21:
            var startOfExpirationDate = currentASN1PayloadLocation
            expirationDate = DecodeASN1Date(startOfDate: &#038;startOfExpirationDate, length: length)
        default:
            break
        }

        currentASN1PayloadLocation = currentASN1PayloadLocation?.advanced(by: length)
    }

    // Strategy Step 4: Return ParsedReceipt
    return ParsedReceipt(bundleIdentifier: bundleIdentifier,
                            bundleIdData: bundleIdData,
                            appVersion: appVersion,
                            opaqueValue: opaqueValue,
                            sha1Hash: sha1Hash,
                            inAppPurchaseReceipts: inAppPurchaseReceipts,
                            originalAppVersion: originalAppVersion,
                            receiptCreationDate: receiptCreationDate,
                            expirationDate: expirationDate)
}
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

func parseInAppPurchaseReceipt(currentInAppPurchaseASN1PayloadLocation: inout UnsafePointer<UInt8>?, payloadLength: Int) throws -> ParsedInAppPurchaseReceipt {
    var quantity: Int?
    var productIdentifier: String?
    var transactionIdentifier: String?
    var originalTransactionIdentifier: String?
    var purchaseDate: Date?
    var originalPurchaseDate: Date?
    var subscriptionExpirationDate: Date?
    var cancellationDate: Date?
    var webOrderLineItemId: Int?

    // Find the end of the in-app purchase receipt payload
    let endOfPayload = currentInAppPurchaseASN1PayloadLocation!.advanced(by: payloadLength)
    var type = Int32(0)
    var xclass = Int32(0)
    var length = 0

    ASN1_get_object(&currentInAppPurchaseASN1PayloadLocation, &length, &type, &xclass, payloadLength)

    // Payload must be an ASN1 Set
    guard type == V_ASN1_SET else {
        throw ReceiptValidationError.malformedInAppPurchaseReceipt
    }

    // Decode Payload
    // Step through payload (ASN1 Set) and parse each ASN1 Sequence within (ASN1 Sets contain one or more ASN1 Sequences)
    while currentInAppPurchaseASN1PayloadLocation! < endOfPayload {

        // Get next ASN1 Sequence
        ASN1_get_object(&#038;currentInAppPurchaseASN1PayloadLocation, &#038;length, &#038;type, &#038;xclass, currentInAppPurchaseASN1PayloadLocation!.distance(to: endOfPayload))

        // ASN1 Object type must be an ASN1 Sequence
        guard type == V_ASN1_SEQUENCE else {
            throw ReceiptValidationError.malformedInAppPurchaseReceipt
        }

        // Attribute type of ASN1 Sequence must be an Integer
        guard let attributeType = DecodeASN1Integer(startOfInt: &#038;currentInAppPurchaseASN1PayloadLocation, length: currentInAppPurchaseASN1PayloadLocation!.distance(to: endOfPayload)) else {
            throw ReceiptValidationError.malformedInAppPurchaseReceipt
        }

        // Attribute version of ASN1 Sequence must be an Integer
        guard DecodeASN1Integer(startOfInt: &#038;currentInAppPurchaseASN1PayloadLocation, length: currentInAppPurchaseASN1PayloadLocation!.distance(to: endOfPayload)) != nil else {
            throw ReceiptValidationError.malformedInAppPurchaseReceipt
        }

        // Get ASN1 Sequence value
        ASN1_get_object(&#038;currentInAppPurchaseASN1PayloadLocation, &#038;length, &#038;type, &#038;xclass, currentInAppPurchaseASN1PayloadLocation!.distance(to: endOfPayload))

        // ASN1 Sequence value must be an ASN1 Octet String
        guard type == V_ASN1_OCTET_STRING else {
            throw ReceiptValidationError.malformedInAppPurchaseReceipt
        }

        // Decode attributes
        switch attributeType {
        case 1701:
            var startOfQuantity = currentInAppPurchaseASN1PayloadLocation
            quantity = DecodeASN1Integer(startOfInt: &#038;startOfQuantity , length: length)
        case 1702:
            var startOfProductIdentifier = currentInAppPurchaseASN1PayloadLocation
            productIdentifier = DecodeASN1String(startOfString: &#038;startOfProductIdentifier, length: length)
        case 1703:
            var startOfTransactionIdentifier = currentInAppPurchaseASN1PayloadLocation
            transactionIdentifier = DecodeASN1String(startOfString: &#038;startOfTransactionIdentifier, length: length)
        case 1705:
            var startOfOriginalTransactionIdentifier = currentInAppPurchaseASN1PayloadLocation
            originalTransactionIdentifier = DecodeASN1String(startOfString: &#038;startOfOriginalTransactionIdentifier, length: length)
        case 1704:
            var startOfPurchaseDate = currentInAppPurchaseASN1PayloadLocation
            purchaseDate = DecodeASN1Date(startOfDate: &#038;startOfPurchaseDate, length: length)
        case 1706:
            var startOfOriginalPurchaseDate = currentInAppPurchaseASN1PayloadLocation
            originalPurchaseDate = DecodeASN1Date(startOfDate: &#038;startOfOriginalPurchaseDate, length: length)
        case 1708:
            var startOfSubscriptionExpirationDate = currentInAppPurchaseASN1PayloadLocation
            subscriptionExpirationDate = DecodeASN1Date(startOfDate: &#038;startOfSubscriptionExpirationDate, length: length)
        case 1712:
            var startOfCancellationDate = currentInAppPurchaseASN1PayloadLocation
            cancellationDate = DecodeASN1Date(startOfDate: &#038;startOfCancellationDate, length: length)
        case 1711:
            var startOfWebOrderLineItemId = currentInAppPurchaseASN1PayloadLocation
            webOrderLineItemId = DecodeASN1Integer(startOfInt: &#038;startOfWebOrderLineItemId, length: length)
        default:
            break
        }

        currentInAppPurchaseASN1PayloadLocation = currentInAppPurchaseASN1PayloadLocation!.advanced(by: length)
    }

    return ParsedInAppPurchaseReceipt(quantity: quantity,
                                        productIdentifier: productIdentifier,
                                        transactionIdentifier: transactionIdentifier,
                                        originalTransactionIdentifier: originalTransactionIdentifier,
                                        purchaseDate: purchaseDate,
                                        originalPurchaseDate: originalPurchaseDate,
                                        subscriptionExpirationDate: subscriptionExpirationDate,
                                        cancellationDate: cancellationDate,
                                        webOrderLineItemId: webOrderLineItemId)
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

enum ReceiptValidationResult {
    case success(ParsedReceipt) // Now has ParsedReceipt for an associated value
    case error(ReceiptValidationError)
}

struct ReceiptValidator {
    let receiptLoader = ReceiptLoader()
    let receiptExtractor = ReceiptExtractor()
    let receiptSignatureValidator = ReceiptSignatureValidator()
    let receiptParser = ReceiptParser()

    func validateReceipt() -> ReceiptValidationResult {
        do {
            let receiptData = try receiptLoader.loadReceipt()
            let receiptContainer = try receiptExtractor.extractPKCS7Container(receiptData)

            try receiptSignatureValidator.checkSignaturePresence(receiptContainer)
            try receiptSignatureValidator.checkSignatureAuthenticity(receiptContainer)

            let parsedReceipt = try receiptParser.parse(receiptContainer)
            return .success(parsedReceipt)
        } catch {
            return .error(error as! ReceiptValidationError)
        }
    }
}
1
2
3
4

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
    case emptyReceiptContents
}
1
2
3
4
5
6
7

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
    case emptyReceiptContents
    case receiptNotSigned
    case appleRootCertificateNotFound
    case receiptSignatureInvalid
}
1
2
3
4
5
6
7
8
9

struct ReceiptSignatureValidator {
    func checkSignaturePresence(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        // Implementation coming
    }

    func checkSignatureAuthenticity(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        // Implementation coming
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

struct ReceiptSignatureValidator {
    func checkSignaturePresence(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        let pkcs7SignedTypeCode = OBJ_obj2nid(PKCS7Container.pointee.type)

        guard pkcs7SignedTypeCode == NID_pkcs7_signed else {
            throw ReceiptValidationError.receiptNotSigned
        }
    }

    func checkSignatureAuthenticity(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        // Implementation coming
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

fileprivate func loadAppleRootCertificate() throws -> UnsafeMutablePointer<X509> {
    guard
        let appleRootCertificateURL = Bundle.main.url(forResource: "AppleIncRootCertificate", withExtension: "cer"),
        let appleRootCertificateData = try? Data(contentsOf: appleRootCertificateURL)
        else {
            throw ReceiptValidationError.appleRootCertificateNotFound
    }

    //①
    let appleRootCertificateBIO = BIO_new(BIO_s_mem())

    //②
    BIO_write(appleRootCertificateBIO, (appleRootCertificateData as NSData).bytes, Int32(appleRootCertificateData.count))

    //③
    let appleRootCertificateX509 = d2i_X509_bio(appleRootCertificateBIO, nil)

    return appleRootCertificateX509!
}
1

BIO_write(appleRootCertificateBIO, (appleRootCertificateData as NSData).bytes, Int32(appleRootCertificateData.count))
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

fileprivate func verifyAuthenticity(_ x509Certificate: UnsafeMutablePointer<X509>, PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
    //①
    let x509CertificateStore = X509_STORE_new()

    //②
    X509_STORE_add_cert(x509CertificateStore, x509Certificate)

    //③
    OpenSSL_add_all_digests()

    //④
    let result = PKCS7_verify(PKCS7Container, nil, x509CertificateStore, nil, nil, 0)

    //⑤
    if result != 1 {
        throw ReceiptValidationError.receiptSignatureInvalid
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

struct ReceiptSignatureValidator {
    func checkSignaturePresence(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        let pkcs7SignedTypeCode = OBJ_obj2nid(PKCS7Container.pointee.type)

        guard pkcs7SignedTypeCode == NID_pkcs7_signed else {
            throw ReceiptValidationError.receiptNotSigned
        }
    }

    func checkSignatureAuthenticity(_ PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        let appleRootCertificateX509 = try loadAppleRootCertificate()

        try verifyAuthenticity(appleRootCertificateX509, PKCS7Container: PKCS7Container)
    }

    fileprivate func loadAppleRootCertificate() throws -> UnsafeMutablePointer<X509> {
        guard
            let appleRootCertificateURL = Bundle.main.url(forResource: "AppleIncRootCertificate", withExtension: "cer"),
            let appleRootCertificateData = try? Data(contentsOf: appleRootCertificateURL)
            else {
                throw ReceiptValidationError.appleRootCertificateNotFound
        }

        let appleRootCertificateBIO = BIO_new(BIO_s_mem())
        BIO_write(appleRootCertificateBIO, (appleRootCertificateData as NSData).bytes, Int32(appleRootCertificateData.count))
        let appleRootCertificateX509 = d2i_X509_bio(appleRootCertificateBIO, nil)

        return appleRootCertificateX509!
    }

    fileprivate func verifyAuthenticity(_ x509Certificate: UnsafeMutablePointer<X509>, PKCS7Container: UnsafeMutablePointer<PKCS7>) throws {
        let x509CertificateStore = X509_STORE_new()
        X509_STORE_add_cert(x509CertificateStore, x509Certificate)

        OpenSSL_add_all_digests()

        let result = PKCS7_verify(PKCS7Container, nil, x509CertificateStore, nil, nil, 0)

        if result != 1 {
            throw ReceiptValidationError.receiptSignatureInvalid
        }
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

struct ReceiptValidator {
    let receiptLoader = ReceiptLoader()
    let receiptExtractor = ReceiptExtractor()
    let receiptSignatureValidator = ReceiptSignatureValidator()

    func validateReceipt() -> ReceiptValidationResult {
        do {
            let receiptData = try receiptLoader.loadReceipt()
            let receiptContainer = try receiptExtractor.extractPKCS7Container(receiptData)

            try receiptSignatureValidator.checkSignaturePresence(receiptContainer)
            try receiptSignatureValidator.checkSignatureAuthenticity(receiptContainer)
            return .success
        } catch {
            return .error(error as! ReceiptValidationError)
        }
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

override public func viewDidLoad() {
    super.viewDidLoad()

    let validationResult = receiptValidator.validateReceipt()

    switch validationResult {
    case .success:
        // Enable app features
    case .error(let error):
        print(error)
        receiptRequest.start()
    }   
}
1// Configure NSPersistentStoreCoordinator with an NSPersistentStore
2let psc = NSPersistentStoreCoordinator(managedObjectModel: model) // model instance creation not shown here...
3
4let storeURL = try! FileManager
5        .default
6        .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
7        .appendingPathComponent("NameOfDataModel.sqlite")
8
9try! psc.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)

 1let container = NSPersistentContainer(name: "NameOfDataModel")
 2
 3let storeURL = try! FileManager
 4        .default
 5        .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
 6        .appendingPathComponent("NameOfDataModel.sqlite")
 7
 8let storeDescription = NSPersistentStoreDescription(url: storeURL)
 9container.persistentStoreDescriptions = [storeDescription]
10
11// Remaining setup for NSPersistentContainer

<p>
  <a name="share" class="jump-target"></a>
</p>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

//Step 1
let container = NSPersistentContainer(name: "NameOfModel")

// Step 2
// Happens asynchronously!
container.loadPersistentStores(completionHandler: {
    persistentStoreDescription, error in
    // Step 3
    guard error == nil else { fatalError("Failed to load store: \(error)") }

    let mainContext = container.viewContext
    // Use the context to do Core Data stuff in your app
})
1var completionHandlers: [() -> Void] = []
2
3func doSomething(completion: () -> Void) {
4    completionHandlers.append(completion)
5}

1func doSomething(completion: () -> Void) {
2    doSomeOtherAsynchronousThing(completion: {
3    () -> Void in
4    // code that executes after the other asynchronous thing is done
5    completion()
6    })
7}

1

@NSManaged var createdOn: Date //instead of Date? (ie, the ? is missing)
1var greetings: [String]? = ["Howdy!", "Hello!"]
2var salutations: [String]? = ["Hi!", "Hey!"]

1if let g = greetings, let s = salutations {
2    print(g)
3    print(s)
4}

1var greetings: [String]? = ["Howdy!", "Hello!"]
2var salutations: nil

1if let g = greetings, let s = salutations {
2    print(g)
3    print(s)
4}

1if let g = greetings {
2    print(g)
3}
4
5if let s = salutations {
6    print(s)
7}

1
2
3

// Initialize NSManagedObjectModel
let modelURL = Bundle.main.url(forResource: "NameOfDataModel", withExtension: "momd")
guard let model = NSManagedObjectModel(contentsOf: modelURL!) else { fatalError("model not found") }
1
2
3
4
5
6
7
8
9

// Configure NSPersistentStoreCoordinator with an NSPersistentStore
let psc = NSPersistentStoreCoordinator(managedObjectModel: model)

let storeURL = try! FileManager
        .default
        .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
        .appendingPathComponent("NameOfDataModel.sqlite")

try! psc.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)
1
2
3

// Create and return NSManagedObjectContext
let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
context.persistentStoreCoordinator = psc
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func createMainContext() -> NSManagedObjectContext {

    // Initialize NSManagedObjectModel
    let modelURL = Bundle.main.url(forResource: "NameOfDataModel", withExtension: "momd")
    guard let model = NSManagedObjectModel(contentsOf: modelURL!) else { fatalError("model not found") }

    // Configure NSPersistentStoreCoordinator with an NSPersistentStore
    let psc = NSPersistentStoreCoordinator(managedObjectModel: model)

    let storeURL = try! FileManager
            .default
            .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
            .appendingPathComponent("NameOfDataModel.sqlite")

    try! psc.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)

    // Create and return NSManagedObjectContext
    let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
    context.persistentStoreCoordinator = psc

    return context
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

extension URL {
    static var documentsURL: URL {
        return try! FileManager
            .default
            .url(for: .documentDirectory, 
                 in: .userDomainMask, 
                 appropriateFor: nil, 
                 create: true)
    }
}
1
2
3
4
5

// ...

let storeURL = URL.documentsURL.appendingPathComponent("AppDatabase.sqlite")

// use the URL
1protected override void OnModelCreating(DbModelBuilder modelBuilder)
2{
3    modelBuilder.Entity<NameOfEntity>()
4                .Property(p => p.NameOfProperty)
5                .HasPrecision(9, 4); // or whatever your schema specifies
6}

1protected void Application_Start()
2{
3    // Enables use of spatial data types
4    SqlServerTypes.Utilities.LoadNativeAssemblies(Server.MapPath("~/bin"));
5
6    // Other registrations...
7}

 1public partial class _Default : System.Web.UI.Page
 2{
 3    static bool _isSqlTypesLoaded = false;
 4
 5    public _Default()
 6    {
 7        if (!_isSqlTypesLoaded)
 8        {
 9            SqlServerTypes.Utilities.LoadNativeAssemblies(Server.MapPath("~"));
10            _isSqlTypesLoaded = true;
11        }
12        
13    }
14}

1SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);

    SqlProviderServices.SqlServerTypesAssemblyName =
    "Microsoft.SqlServer.Types, Version=14.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91";

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import UIKit
import CoreData

// Core Data Stack Setup for In-Memory Store
public func createMainContext() -> NSManagedObjectContext {

    // Replace "Model" with the name of your model
    let modelUrl = NSBundle.mainBundle().URLForResource("Model", withExtension: "momd")
    guard let model = NSManagedObjectModel.init(contentsOfurl: modelUrl!) else { fatalError("model not found") }

    let psc = NSPersistentStoreCoordinator(managedObjectModel: model)
    try! psc.addPersistentStoreWithType(NSInMemoryStoreType, configuration: nil, URL: nil, options: nil)

    let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
    context.persistentStoreCoordinator = psc

    return context
}

let context = createMainContext()

// Insert a new Entity
let ent = NSEntityDescription.insertNewObjectForEntityForName("Entity", inManagedObjectContext: context)
ent.setValue(42, forKey: "attribute")

try! context.save()

// Perform a fetch request
let fr = NSFetchRequest(entityName: "Entity")
let result = try! context.executeFetchRequest(fr)

print(result)
1
2
3

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
}
1
2
3
4
5
6

struct ReceiptExtractor {
    func extractPKCS7Container(_ receiptData: Data) throws -> UnsafeMutablePointer<PKCS7> {
        // use Open SSL to extract the PKCS7 container
        // throw a ReceiptValidationError if something goes wrong in this process
    }
}
1
2
3
4

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
    case emptyReceiptContents
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#ifndef pkcs7_union_accessors_h
#define pkcs7_union_accessors_h

#include <openssl/pkcs7.h>

char *pkcs7_d_char(PKCS7 *ptr);
ASN1_OCTET_STRING *pkcs7_d_data(PKCS7 *ptr);
PKCS7_SIGNED *pkcs7_d_sign(PKCS7 *ptr);
PKCS7_ENVELOPE *pkcs7_d_enveloped(PKCS7 *ptr);
PKCS7_SIGN_ENVELOPE *pkcs7_d_signed_and_enveloped(PKCS7 *ptr);
PKCS7_DIGEST *pkcs7_d_digest(PKCS7 *ptr);
PKCS7_ENCRYPT *pkcs7_d_encrypted(PKCS7 *ptr);
ASN1_TYPE *pkcs7_d_other(PKCS7 *ptr);

#endif /* pkcs7_union_accessors_h */
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include "pkcs7_union_accessors.h"

inline char *pkcs7_d_char(PKCS7 *ptr) {
    return ptr->d.ptr;
}

inline ASN1_OCTET_STRING *pkcs7_d_data(PKCS7 *ptr) {
    return ptr->d.data;
}

inline PKCS7_SIGNED *pkcs7_d_sign(PKCS7 *ptr) {
    return ptr->d.sign;
}

inline PKCS7_ENVELOPE *pkcs7_d_enveloped(PKCS7 *ptr) {
    return ptr->d.enveloped;
}

inline PKCS7_SIGN_ENVELOPE *pkcs7_d_signed_and_enveloped(PKCS7 *ptr) {
    return ptr->d.signed_and_enveloped;
}

inline PKCS7_DIGEST *pkcs7_d_digest(PKCS7 *ptr) {
    return ptr->d.digest;
}

inline PKCS7_ENCRYPT *pkcs7_d_encrypted(PKCS7 *ptr) {
    return ptr->d.encrypted;
}

inline ASN1_TYPE *pkcs7_d_other(PKCS7 *ptr) {
    return ptr->d.other;
}
1
2
3

#import <openssl/pkcs7.h>
#import <openssl/objects.h>
#import "pkcs7_union_accessors.h"
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

struct ReceiptExtractor {
    func extractPKCS7Container(_ receiptData: Data) throws -> UnsafeMutablePointer<PKCS7> {
        let receiptBIO = BIO_new(BIO_s_mem())       
        BIO_write(receiptBIO, (receiptData as NSData).bytes, Int32(receiptData.count))
        let receiptPKCS7Container = d2i_PKCS7_bio(receiptBIO, nil)

        guard receiptPKCS7Container != nil else {
            throw ReceiptValidationError.emptyReceiptContents
        }

        let pkcs7DataTypeCode = OBJ_obj2nid(pkcs7_d_sign(receiptPKCS7Container).pointee.contents.pointee.type)

        guard pkcs7DataTypeCode == NID_pkcs7_data else {
            throw ReceiptValidationError.emptyReceiptContents
        }

        return receiptPKCS7Container!
    }
}
 1class AddEventViewController: UIViewController {
 2
 3    var calendar: EKCalendar! // Intended to be set in parent controller's prepareForSegue event
 4
 5    @IBOutlet weak var eventNameTextField: UITextField!
 6    @IBOutlet weak var eventStartDatePicker: UIDatePicker!
 7    @IBOutlet weak var eventEndDatePicker: UIDatePicker!
 8
 9    // ...
10
11    @IBAction func addEventButtonTapped(sender: UIBarButtonItem) {
12        // Create an Event Store instance
13        let eventStore = EKEventStore();
14        
15        // Use Event Store to create a new calendar instance
16        if let calendarForEvent = eventStore.calendarWithIdentifier(self.calendar.calendarIdentifier)
17        {
18            let newEvent = EKEvent(eventStore: eventStore)
19            
20            newEvent.calendar = calendarForEvent
21            newEvent.title = self.eventNameTextField.text ?? "Some Event Name"
22            newEvent.startDate = self.eventStartDatePicker.date
23            newEvent.endDate = self.eventEndDatePicker.date
24            
25            // Save the calendar using the Event Store instance
26            
27            do {
28                try eventStore.saveEvent(newEvent, span: .ThisEvent, commit: true)
29                delegate?.eventDidAdd()
30                
31                self.dismissViewControllerAnimated(true, completion: nil)
32            } catch {
33                let alert = UIAlertController(title: "Event could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
34                let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
35                alert.addAction(OKAction)
36                
37                self.presentViewController(alert, animated: true, completion: nil)
38            }
39        }
40     }
41
42     // ...
43}

1let newEvent = EKEvent(eventStore: eventStore)

1if let calendarForEvent = eventStore.calendarWithIdentifier(self.calendar.calendarIdentifier) { 
2// ... 
3}

1let newEvent = EKEvent(eventStore: eventStore)
2            
3newEvent.calendar = calendarForEvent
4newEvent.title = self.eventNameTextField.text ?? "Some Event Name"
5newEvent.startDate = self.eventStartDatePicker.date
6newEvent.endDate = self.eventEndDatePicker.date

 1do {
 2    try eventStore.saveEvent(newEvent, span: .ThisEvent, commit: true)
 3    delegate?.eventDidAdd()
 4    
 5    self.dismissViewControllerAnimated(true, completion: nil)
 6} catch {
 7    let alert = UIAlertController(title: "Event could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
 8    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
 9    alert.addAction(OKAction)
10    
11    self.presentViewController(alert, animated: true, completion: nil)
12}

1if let calendarForEvent = eventStore.calendarWithIdentifier((self.calendar.calendarIdentifier))
2{
3    let newEvent = EKEvent(eventStore: eventStore)
4    
5    newEvent.calendar = calendarForEvent
6    
7    // ...
8}

 1import UIKit
 2
 3/*: 
 4# Overview
 5This is a cheat sheet for working with dates, date formatters, and date components.
 6
 7*/
 8
 9//: # Today's Date
10
11let today = NSDate()
12let thisTimeTomrrow = NSDate(timeIntervalSinceNow: 86400)
13let thisTimeYesterday = NSDate(timeIntervalSinceNow: -86400)
14
15/*: 
16# Date Formatting
17Working with NSDateFormatter to convert dates to stings and vice-versa
18*/
19
20//: ## Converting dates to strings
21let dateFormatter = NSDateFormatter()
22dateFormatter.dateFormat = "yyyy-MM-dd"
23
24print(dateFormatter.stringFromDate(today))
25
26dateFormatter.dateFormat = "MMM dd, yyyy"
27
28print(dateFormatter.stringFromDate(today))
29
30
31//: ## Converting strings to dates
32
33// Consider what might potentially come back from an API of some sort and set a dateFormatter's dateFormat property appropriately...
34
35dateFormatter.dateFormat = "yyyy-MM-dd"
36var stringFromApi = "2016-01-01"
37var date = dateFormatter.dateFromString(stringFromApi)
38
39stringFromApi = "May 26, 2016"
40date = dateFormatter.dateFromString(stringFromApi)
41
42/* Notice how the format set to the date formatter (yyyy-MM-dd) differs from the format that came back from the API (MMM dd, yyyy), which resulted in `date` being nil.
43*/
44
45/*:
46# Date Components
47Working with NSCalendar and NSCalendarUnit to work with components of dates.
48*/
49
50//: ## Getting date components
51var calendarUnitFlags: NSCalendarUnit = [.Year, .Month, .Day, .Hour, .Minute, .Second]
52var dateComponents = NSCalendar.currentCalendar().components(calendarUnitFlags, fromDate: NSDate())
53dateComponents.year
54dateComponents.month
55dateComponents.day
56dateComponents.hour
57dateComponents.minute
58dateComponents.second
59
60// Observe how leaving out .Hour, .Minute, and .Second affects the values of those components of a date:
61calendarUnitFlags = [.Year, .Month, .Day]
62dateComponents = NSCalendar.currentCalendar().components(calendarUnitFlags, fromDate: NSDate())
63dateComponents.year
64dateComponents.month
65dateComponents.day
66dateComponents.hour
67dateComponents.minute
68dateComponents.second
69
70//: ## Setting date component values
71
72dateComponents.year = dateComponents.year + 1
73dateComponents.month = 1
74dateComponents.day = 1
75dateComponents.hour = 0
76dateComponents.minute = 0
77dateComponents.second = 0
78
79//: ## Creating dates from components
80let newDate = NSCalendar.currentCalendar().dateFromComponents(dateComponents)

 1func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject : AnyObject]?) -> Bool {
 2    // Override point for customization after application launch.
 3    let configuration = ParseClientConfiguration {
 4        $0.applicationId = "YourAppId"
 5        $0.clientKey = "YourClientKey"
 6        $0.server = "https://your-self-hosted-parse-server/parse"
 7    }
 8    Parse.initializeWithConfiguration(configuration)
 9    
10    return true
11}

 1struct Vehicle<Fuel> {
 2    let move: (Fuel) -> Void
 3}
 4
 5// Fuel Types
 6struct Gas {}
 7struct RocketFuel {}
 8
 9let car = Vehicle<Gas>(move: { _ in print("use gasoline to move") })
10
11let rocket = Vehicle<RocketFuel>(move: { _ in print("use rocket fuel to move") })
12
13car.move(Gas())
14rocket.move(RocketFuel())

1func getData(completion: (NSData) -> Void) {
2    let data: NSData = // do something to go get data
3
4    // call completion handler when getting data is done
5    completion(data)
6}

 1class EventsViewController: UIViewController, UITableViewDataSource {
 2    var calendar: EKCalendar! // Passed in from previous view controller
 3    var events: [EKEvent]?
 4
 5    // ...
 6
 7    func loadEvents() {
 8        // Create a date formatter instance to use for converting a string to a date
 9        let dateFormatter = NSDateFormatter()
10        dateFormatter.dateFormat = "yyyy-MM-dd"
11        
12        // Create start and end date NSDate instances to build a predicate for which events to select
13        let startDate = dateFormatter.dateFromString("2016-01-01")
14        let endDate = dateFormatter.dateFromString("2016-12-31")
15        
16        if let startDate = startDate, endDate = endDate {
17            let eventStore = EKEventStore()
18            
19            // Use an event store instance to create and properly configure an NSPredicate
20            let eventsPredicate = eventStore.predicateForEventsWithStartDate(startDate, endDate: endDate, calendars: [calendar])
21            
22            // Use the configured NSPredicate to find and return events in the store that match
23            self.events = eventStore.eventsMatchingPredicate(eventsPredicate).sort(){
24                (e1: EKEvent, e2: EKEvent) -> Bool in
25                return e1.startDate.compare(e2.startDate) == NSComparisonResult.OrderedAscending
26            }
27        }
28    }
29    // ...
30}

{
  "apps": [
    {
        "serverURL": "http://url-to-your-parse-server/parse", // If your Parse Server's endpoint is not at /parse, you need to replace /parse with the correct endpoint
        "appId": "your-app-Id",
        "masterKey": "your-master-key",
        "appName": "your-app-name"
    }
  ],
  "users": [
    {
      "user":"username1", // Used to log in to your Parse Dashboard
      "pass":"password1"
    }
  ]
}
```

# 4 – Modify local .gitignore

Your local .gitignore file ignores some needed directories that, while helpful to ignore in the actual Open Source parse-dashboard repo on GitHub, are _not_ as helpful to ignore when you need to deploy the dashboard to a cloud host.

Edit the .gitignore file using a text editor and remove these three lines:

bundles/
Parse-Dashboard/public/bundles/
Parse-Dashboard/parse-dashboard-config.json
```

# 5 – Stage and commit all changes

Stage all of the changes you've made to the parse-dashboard-config.json and the .gitignore files, and add the files and directories that were previously ignored by git by running `git add -A`

Then commit the staged changes:  
`git commit -m "Prepared app for deployment"`

# 6 – Set up private git repository

Since you're storing values that are intended to be kept secret (such as your app's Master Key), you need to set up a private git repository that can be used for two purposes: 1) To keep your configuration under source control and 2) to be able to use as a deployment source for your cloud host provider.

The idea is that you can wire up your cloud app in Azure/Heroku/AWS/wherever to refresh itself every time you commit code to the master branch of this private repository. It's really handy for making updates.

[Bitbucket][2] offers its members unlimited private repositories, so that's where I've chosen to host mine.

# 7 – Add new remote to your local parse-dashboard git repository

With the new private repository set up, you need to add it as a remote to your local parse-dashboard repo.

In the Terminal, make sure you're in the directory of your local parse-dashboard git repository and run:

git remote add privateorigin https://url-to-your-private-parse-dashboard-repo
```

# 8 – Push to your private git repository

With all the changes to your configuration committed and the new remote repository added, you can push those changes up to that repo:

In the Terminal, make sure you're in the directory of your local parse-dashboard git repository and run:

git push -u privateorigin --all # pushes up the repo and its refs for the first time
git push privateorigin --tags # pushes up any tags
```

# 9 – Create app on the cloud host

Now you need to create a new app in your hosting provider of choice. I typically go with [Azure][3], because I'm most familiar with it. I also like that they offer a completely free option, though if you want to really run this stuff for a larger-scale "production” or "enterprise” app, it's going to cost no matter where you choose to host it.

The cloud host may want to know what flavor of app you want to create. In the case of parse-dashboard, it's a Node.JS app.

# 10 – Configure cloud host for git deployment

Once you've created a new Node app on your cloud host of choice, you need to configure it for git deployment.

This step will be different for each cloud host, but the general idea is that you should be able to configure your private git repository that you set up in Step 5, to be the source from which the cloud host will go out, grab the code, and perform the necessary steps to get the Parse Dashboard bootstrapped for access.

In Azure, you simply click on your app, and configure git deployment in the Deployment Source settings:

[][4]

You might check out [Heroku's startup guide][5] for help on deploying to their service.

Note that instead of doing the git deployment option, you could always FTP your whole parse-dashboard directory (the one that you cloned and ran `npm install` inside), if your cloud host supports this deployment option.

# 11 – Enable SSL (or run as insecure app)

If you access your app after you've deployed it to your chosen cloud host, you'll likely run into an error page stating that "Parse Dashboard can only be remotely accessed via HTTPS”.

Configuring SSL is beyond the scope of this walk-through, but that would be the next step if you chose to do it for your production app. Note that on Azure, your App Service Plan needs to be at "Basic” or above. Heroku charges a monthly fee to set up an SSL endpoint as well.

If you choose not to afford it or if you just want to test things out in the deployed environment to see if it's working or not, you can set up an environment variable in your app's settings on the cloud host.

In Azure, you need to choose your app, then go to "Application Settings” in the Azure Portal. Then add a new key-value pair under App settings: PARSE\_DASHBOARD\_ALLOW\_INSECURE\_HTTP is the key, and 1 (the number 1) is the value:

[][6]

In Heroku, you need to go to your app's Settings, and then add a new Config Var with the same key-value pair:  
[][7]

    You might also enjoy…

       FIX – Query in Parse Cloud Code Returns Unauthorized Error

 [1]: https://github.com/ParsePlatform/parse-dashboard
 [2]: http://www.bitbucket.com
 [3]: https://azure.microsoft.com/en-us/
 [4]: https://www.andrewcbancroft.com/wp-content/uploads/2016/04/AzureGitDeployment1.png
 [5]: https://devcenter.heroku.com/articles/getting-started-with-nodejs#introduction
 [6]: https://www.andrewcbancroft.com/wp-content/uploads/2016/04/AzureAppSettings1.png
 [7]: https://www.andrewcbancroft.com/wp-content/uploads/2016/04/HerokuConfigVars.png

var query = new Parse.Query("NameOfParseClassImFetching");

query.find({
    success: function(results){
        // Do things with the results
    },
    error: function(error) {
        response.error(error);
    }
});
```

When the details came back as to what was failing, the JSON object in the response looked like this:

{
  "code": 141,
  "error": {
    "message": "unauthorized"
  }
}
```

I got to searching and found an [issue on GitHub][1] that pointed me in the right direction, but to spare you reading through the entire thread, here's the gist:

# Solution

I happened to be using a version of the Parse Server Example that was missing a critical line of configuration in index.js. When you configure your Parse Server by calling `new ParseServer`, you need to make sure that there's a `serverURL` property that's set to the URL of your Parse Server's API endpoint.

My config didn't have this, but the moment I added it, my Cloud Code queries worked perfectly as they did before. Here's a look at my final index.js file with the relevant line highlighted:

// Example express application adding the parse-server module to expose Parse
// compatible API routes.

var express = require('express');
var ParseServer = require('parse-server').ParseServer;

var databaseUri = process.env.DATABASE_URI || process.env.MONGOLAB_URI

if (!databaseUri) {
  console.log('DATABASE_URI not specified, falling back to localhost.');
}

var api = new ParseServer({
  databaseURI: databaseUri || 'mongodb://localhost:27017/dev',
  cloud: process.env.CLOUD_CODE_MAIN || __dirname + '/cloud/main.js',
  appId: process.env.APP_ID || 'myAppId',
  masterKey: process.env.MASTER_KEY || '', //Add your master key here. Keep it secret!
  serverurl: 'http://url-to-your-parse-api-endpoint/parse'
});
// Client-keys like the javascript key or the .NET key are not necessary with parse-server
// If you wish you require them, you can set them as options in the initialization above:
// javascriptKey, restAPIKey, dotNetKey, clientKey

var app = express();

// Serve the Parse API on the /parse URL prefix
var mountPath = process.env.PARSE_MOUNT || '/parse';
app.use(mountPath, api);

// Parse Server plays nicely with the rest of your web routes
app.get('/', function(req, res) {
  res.status(200).send('I dream of being a web site.');
});

var port = process.env.PORT || 1337;
app.listen(port, function() {
    console.log('parse-server-example running on port ' + port + '.');
});
```

I hope this little breadcrumb finds its way to someone before _they_ spend 3 hours on a silly configuration issue.

 [1]: https://github.com/ParsePlatform/parse-server/issues/356

1class SomeNewClassType {}
2
3struct SomeNewStructType {}
4
5enum SomeNewEnumType {}
6
7protocol SomeNewProtocolType {}

1func generateStarWarsName(firstName: String, lastName: String, birthYear: Int) -> String { 
2    // ... 
3}

1func complimentMe(name: String) -> String { 
2    // ... 
3}

1func countToTen() { 
2    // ... prints 1 to 10 to the console ...
3}

1func addInts(first: Int, second: Int) -> Int { 
2    // ... 
3}

1func fadeIn(duration: NSTimeInterval, delay: NSTimeInterval, completion: (Bool) -> Void){ 
2    // ... 
3}

<p>
</p>

```swift

    <p>
      <a id="show-answer-5" style="cursor: pointer;">Show answer</a>
    </p>

    <div id="answer-5" style="display: none;">
      increment: `(Int) -> Int`<br /> decrement: `(Int) -> Int`</p> 

      <p>
        chooseAdjustmentFunction(_:): `(Bool) -> (Int) -> Int`
      </p>

      <p>
        This one's complicated in a slightly different way. This time, it's the return Type of the function that's kind of crazy.
      </p>

      <p>
        Read this as, "A function Type which takes as Bool as a parameter and returns a function Type which takes an Int as a parameter and returns an Int.&#8221;
      </p>

      <p>
        You can see how the Types of the `increment` and `decrement` functions <em>match</em> the return Type of the `chooseAdjustmentFunction` function. </div> 

        <h1>
          Wrapping up
        </h1>

        <p>
          Knowing that functions are Types in Swift is a powerful thing. Being able to correctly articulate the Type of a function, and produce its notation in valid Swift syntax is even <em>more</em> powerful, because it's at that point when you'll be able to recognize which kinds of functions are valid to pass as parameters to <em>other</em> functions, or to assign as properties of other Types. It can also play a role in Swift's pattern matching features. But alas, those topics for another day!
        </p>

        <p>
          <a name="related" class="jump-target"></a>
        </p>

        <div class="resources">
          <div class="resources-header">
            You might also enjoy&#8230;
          </div>

          <ul class="resources-content">
            <li>
              <i class="fa fa-angle-right"></i> <a href="https://www.andrewcbancroft.com/2015/01/06/immutable-types-changing-state-swift/" title="Immutable Types with Changing State in Swift">Immutable Types with Changing State in Swift</a>
            </li>
            <li>
              <i class="fa fa-angle-right"></i> <a href="https://www.andrewcbancroft.com/2015/01/20/conveniently-transforming-immutable-types-swift/" title="Conveniently Transforming Immutable Types in Swift">Conveniently Transforming Immutable Types in Swift</a>
            </li>
          </ul>
        </div>

        <p>
          <a name="share" class="jump-target"></a>
        </p>

        <p>
        </p>

 [1]: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID158

 1import UIKit
 2
 3public protocol Fadeable {
 4    var alpha: CGFloat {get set}
 5    
 6    mutating func fadeIn(duration: NSTimeInterval, delay: NSTimeInterval, completion: (Bool) -> Void)
 7    mutating func fadeOut(duration: NSTimeInterval, delay: NSTimeInterval, completion: (Bool) -> Void)
 8}
 9
10public extension Fadeable {
11    public mutating func fadeIn(duration: NSTimeInterval = 1.0, delay: NSTimeInterval = 0.0, completion: ((Bool) -> Void) = {(finished: Bool) -> Void in}) {
12        UIView.animateWithDuration(duration, delay: delay, options: UIViewAnimationOptions.CurveEaseOut, animations: {
13            self.alpha = 1.0
14            }, completion: completion)  }
15    
16    public mutating func fadeOut(duration: NSTimeInterval = 1.0, delay: NSTimeInterval = 0.0, completion: (Bool) -> Void = {(finished: Bool) -> Void in}) {
17        UIView.animateWithDuration(duration, delay: delay, options: UIViewAnimationOptions.CurveEaseOut, animations: {
18            self.alpha = 0.0
19            }, completion: completion)
20    }
21}
22
23extension UIView: Fadeable {}

 1class ViewController: UIViewController {
 2    
 3    @IBOutlet weak var box: UIView!
 4    
 5    // ... Omitted for brevity   
 6
 7    // The storyboard has a button that can be tapped to toggle the fade action
 8    @IBAction func fadeToggleTapped(sender: UIButton) {
 9        if(box.alpha == 0) {
10            box.fadeIn()
11        } else {
12            box.fadeOut()
13        }
14    }
15}

 1// API Designer World
 2struct SketchAnimation {
 3    // represents some fully-generated animation that's ready to play by the end user
 4}
 5
 6struct ImageSketcher {
 7    func sketch(image: UIImage, completion: (_ sketchAnimation: SketchAnimation) -> Void) {
 8        // do some crunching to create the SketchAnimation instance...
 9        let animation = SketchAnimation()
10        
11        // invoke the completion callback
12        // pass along the completed sketch animation instance
13        completion(animation)
14    }
15}
16
17// ---------------------------------------------------------------------
18
19// Client Developer World
20class MainViewController: UIViewController {
21    // ...
22    
23    // end-user interacts with the app somehow to create an image sketch animation
24    // when they do, this function is called...
25    func createSketchAnimation(imageToSketch: UIImage) {
26        let sketcher = ImageSketcher()
27        
28        sketcher.sketch(image: imageToSketch, completion: {(animation: SketchAnimation) -> Void in
29            // This is the callback.  It's a closure, passed as the argument to the sketch function's completion parameter
30            
31            // Ask the end-user if they'd like to view the completed animation now...
32            // You as a develoepr have access to the completed animation through the animation parameter to this closure
33        })
34    }
35    
36    // ...
37}

 1let alertController = UIAlertController(title: "My Alert", message: "A Message", preferredStyle: UIAlertControllerStyle.alert)
 2
 3let OKAction = UIAlertAction(title: "OK", style: UIAlertActionStyle.default, handler: {(action: UIAlertAction) -> Void in
 4    // Do something based on the user tapping this action button
 5    
 6    // Notice that we get an instance of the UIAlertAction that was tapped if we need it
 7})
 8
 9alertController.addAction(OKAction)
10
11self.present(alertController, animated: true, completion: nil)
12// We could have provided a completion callback here, too,
13// but we didn't need to respond to the view controller's presentation, so we passed nil

1func dataTask(with url: URL, 
2              completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask

1transition(with:duration:options:animations:completion:)
2transition(from:to:duration:options:completion:)
3animateKeyframes(withDuration:delay:options:animations:completion:)
4addKeyframe(withRelativeStartTime:relativeDuration:animations:)
5perform(_:on:options:animations:completion:)
6animate(withDuration:delay:usingSpringWithDamping:initialSpringVelocity:options:animations:completion:)

1class MenuViewController: UITableViewController {
2    
3    // ...
4    
5    @IBAction func unwindToMenu(segue: UIStoryboardSegue) {}
6    
7    // ...
8}

 1@IBAction func orderButtonTapped(_ sender: UIButton) {
 2    let alert = UIAlertController(title: "Order Placed!", message: "Thank you for your order.\nWe'll ship it to you soon!", preferredStyle: .alert)
 3    let OKAction = UIAlertAction(title: "OK", style: UIAlertActionStyle.default, handler: {
 4        (_)in
 5        self.performSegue(withIdentifier: "unwindToMenu", sender: self)
 6    })
 7    
 8    alert.addAction(OKAction)
 9    self.present(alert, animated: true, completion: nil)
10}

1#Note that you should be running PowerShell as an Administrator
2[System.Reflection.Assembly]::Load("System.EnterpriseServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")            
3$publish = New-Object System.EnterpriseServices.Internal.Publish            
4$publish.GacInstall("C:\Path\To\DLL.dll")
5
6#If installing into the GAC on a server hosting web applications in IIS, you need to restart IIS for the applications to pick up the change.
7#Uncomment the next line if necessary...
8#iisreset

1// ...
2
3import UIKit
4import Social
5
6// ...

1@IBAction func postToFacebookTapped(sender: UIButton) {
2    if(SLComposeViewController.isAvailableForServiceType(SLServiceTypeFacebook)) {
3        //...
4    }
5}

1@IBAction func postToFacebookTapped(sender: UIButton) {
2    if(SLComposeViewController.isAvailableForServiceType(SLServiceTypeFacebook)) {
3        let socialController = SLComposeViewController(forServiceType: SLServiceTypeFacebook)
4
5        // ...
6    }
7}

 1@IBAction func postToFacebookTapped(sender: UIButton) {
 2    if(SLComposeViewController.isAvailableForServiceType(SLServiceTypeFacebook)) {
 3        let socialController = SLComposeViewController(forServiceType: SLServiceTypeFacebook)
 4//            socialController.setInitialText("Hello World!")
 5//            socialController.addImage(someUIImageInstance)
 6//            socialController.addURL(someNSURLInstance)
 7        
 8        // ...
 9    }
10}

 1@IBAction func postToFacebookTapped(sender: UIButton) {
 2    if(SLComposeViewController.isAvailableForServiceType(SLServiceTypeFacebook)) {
 3        let socialController = SLComposeViewController(forServiceType: SLServiceTypeFacebook)
 4//            socialController.setInitialText("Hello World!")
 5//            socialController.addImage(someUIImageInstance)
 6//            socialController.addURL(someNSURLInstance)
 7        
 8        self.presentViewController(socialController, animated: true, completion: nil)
 9    }
10}

 1func testAppFeatureBehavior() {
 2    // Arrange
 3    let sut = SystemUnderTest()
 4    // configure properties as necessary to prepare the system for the next step
 5
 6    // Act
 7    sut.functionProducingObservableBehavior()
 8
 9    // Assert
10    XCTAssert(...expectations are met...)
11}

 1func testAppFeatureBehavior() {
 2    // Given
 3    let sut = SystemUnderTest()
 4    // configure properties as necessary to prepare the system for the next step
 5
 6    // When
 7    sut.functionProducingObservableBehavior()
 8
 9    // Then
10    XCTAssert(...expectations are met...)
11}

1
2
3

enum ReceiptValidationError : Error {
    case couldNotFindReceipt
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

enum ReceiptValidationResult {
    case success
    case error(ReceiptValidationError)
}

struct ReceiptValidator {
    let receiptLoader = ReceiptLoader()

    func validateReceipt() -> ReceiptValidationResult {
        do {
            let receiptData = try receiptLoader.loadReceipt()

            // Continue validation steps with receiptData if error not thrown
            return .success
        } catch {
            return .error(error as! ReceiptValidationError)
        }
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

struct ReceiptLoader {
    let receiptUrl = Bundle.main.appStoreReceiptURL

    func loadReceipt() throws -> Data {
        if(receiptFound()) {
            let receiptData = try? Data(contentsOf: receiptUrl!)
            if let receiptData = receiptData {
                return receiptData
            }
        }

        throw ReceiptValidationError.couldNotFindReceipt
    }

    fileprivate func receiptFound() -> Bool {
        do {
            if let isReachable = try receiptUrl?.checkResourceIsReachable() {
                return isReachable
            }
        } catch _ {
            return false
        }

        return false
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class ViewController: UIViewController, SKRequestDelegate {
    let receiptValidator = ReceiptValidator()
    let receiptRequest = SKReceiptRefreshRequest()

    // MARK: View Controller Life Cycle Methods
    override public func viewDidLoad() {
        super.viewDidLoad()
        receiptRequest.delegate = self

        let validationResult = receiptValidator.validateReceipt()

        switch validationResult {
        case .success:
            // Enable app features
        case .error(let error):
            print(error)
            receiptRequest.start()
        }   
    }

    public func requestDidFinish(_ request: SKRequest) {
        do {
            try receiptValidator.validateReceipt()
        } catch {
            // Log unsuccessful attempt and optionally begin grace period
            // before disabling app functionality, or simply disable features
        }
    }

    public func request(_ request: SKRequest, didFailWithError error: Error) {
        // debug error condition
        print(error.localizedDescription)

        // Log unsuccessful attempt and optionally begin grace period
        // before disabling app functionality, or simply disable features
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import Foundation
import StoreKit

class ReceiptFetcher : NSObject, SKRequestDelegate {

    let receiptRefreshRequest = SKReceiptRefreshRequest()

    override init() {
        super.init()
        receiptRefreshRequest.delegate = self
    }

    func fetchReceipt() {
        let receiptUrl = Bundle.main.appStoreReceiptURL

        do {
            if let receiptFound = try receiptUrl?.checkResourceIsReachable() {
                if (receiptFound == false) {
                    receiptRefreshRequest.start()
                }
            }
        } catch {
            print("Could not check for receipt presence for some reason... \(error.localizedDescription)")
        }
    }

    func requestDidFinish(_ request: SKRequest) {
        print("The request finished successfully")
    }

    func request(_ request: SKRequest, didFailWithError error: Error) {
        print("Something went wrong: \(error.localizedDescription)")
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class ViewController: UIViewController {

    // Note that an instance of ReceiptFetcher is kept at the class-level
    let receiptFetcher = ReceiptFetcher()

    override public func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        receiptFetcher.fetchReceipt()
    }
}
1
2
3

target 'NameOfYourApp' do
    pod 'OpenSSL', '~> 1.0'
end
1
2
3

#import <openssl/pkcs7.h>
#import <openssl/objects.h>
// Others that you may need in your Swift project
 1// Prefer
 2public class DatabaseCommunicator {
 3    let database: Database
 4    
 5    public init (database: Database) {
 6        self.database = database
 7        // able to supply a controlled input via parameter, such as supplying a 
 8        // customized "fake" database to use for testing but still supply a "real" database in real life
 9    }
10}
11
12// over
13public class DatabaseCommunicator {
14    let database = Database()
15    // stuck with talking to a real database...
16}

 1// prefer
 2public class DatabaseCommunicator {
 3    public var database: Database
 4    // able to supply a controlled input via property setter, such as supplying a 
 5    // customized "fake" database to use for testing but still supply a "real" database in real life
 6    public init() { self.database = Database()}
 7}
 8
 9// over
10public class DatabaseCommunicator {
11    let database = Database()
12    // stuck with talking to a real database
13}

 1// prefer
 2func getNameFromDatabase(database: Database) -> String {
 3    return database.getName()
 4    // able to supply a controlled input via parameter, such as supplying a 
 5    // customized "fake" database to use for testing but still supply a "real" database in real life
 6   
 7}
 8
 9// over
10func getNameFromDatabase() -> String {
11    let database = Database()
12    // stuck with talking to a real database
13    return database.getName()
14}
15
16// and over
17func getNameFromDatabase() -> String {
18    return self.database.getName()
19    // requires additional setting of the database property on 'self'
20    // before you're able to get results from this function
21}

1
2
3
4
5

lazy var managedObjectModel: NSManagedObjectModel = {
    // The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.
    let modelURL = NSBundle.mainBundle().URLForResource("DataModelFileName", withExtension: "momd")!
    return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
1
2
3
4
5
6
7

lazy var managedObjectModel: NSManagedObjectModel = {
        // The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.
        let carKitBundle = Bundle(identifier: "com.andrewcbancroft.CarKit")

        let modelURL = carKitBundle!.url(forResource: "CarModel", withExtension: "momd")!
        return NSManagedObjectModel(contentsOf: modelURL)!
}()
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.

    let newCar = NSEntityDescription.insertNewObject(forEntityName: "Car", into: self.managedObjectContext!) as! Car
    newCar.year = 2015
    newCar.make = "Tesla"
    newCar.model = "S"

    do {
        try self.managedObjectContext?.save()
    } catch _ {
    }

    let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "Car")
    let cars = (try! self.managedObjectContext?.fetch(fetchRequest)) as! [Car]

    print(cars, terminator: "")

    return true
}
1public interface Athlete
2{
3    public void Run();
4    public void Swim();
5    public void Cycle();
6    // Other things that an Athlete may be able to do
7}

1public abstract class Athlete
2{
3    public abstract void Run();
4    public abstract void Swim();
5    public abstract void Cycle();
6    // Other things that an Athlete may be able to do
7}
1protocol Athlete {
2    func run()
3    func swim()
4    func cycle()
5    // Other things that an Athlete may be able to do
6}

 1{
 2    public virtual void Run()
 3    {
 4        // run with average speed and endurance
 5    }
 6
 7    public virtual void Swim()
 8    {
 9        // swim with average speed and endurance
10    }
11
12    public virtual void Cycle()
13    {
14        // cycle with average speed and endurance
15    }
16}
1{
2    public override void Run()
3    {
4        // run with average speed and __insane__ endurance
5    }
6}
 1extension Athlete {
 2    func run() { // run with average speed and endurance 
 3    }
 4
 5    func swim() { // swim with average speed and endurance 
 6    }
 7
 8    func cycle() { // cycle with average speed and endurance 
 9    }
10}

1class MarathonRunner: Athlete
2{
3    func run() {
4        // run with average speed and __insane__ endurance
5    }
6}

 1protocol Runnable {
 2    func run()
 3}
 4
 5protocol Swimmable {
 6    func swim()
 7}
 8
 9protocol Cycleable {
10    func cycle()
11}

 1extension Runnable {
 2    func run() {
 3        // run with average speed and endurance
 4    }
 5}
 6
 7extension Swimmable {
 8    func swim() {
 9        // swim with average speed and endurance
10    }
11}
12
13extension Cycleable {
14    func cycle() {
15        // cycle with average speed and endurance
16    }
17}

 1struct MarathonRunner: Runnable {
 2    func run() {
 3        // run with average speed and __insane__ endurance
 4    }
 5}
 6
 7struct Triathlete: Runnable, Swimmable, Cycleable {
 8    func swim() {
 9        // swim with lightning speed and crazy endurance
10    }
11
12    // fall back to protocol extension's average run speed & endurance
13    // fall back to protocol extension's average cycle speed and endurance
14}
15
16struct Andrew {
17    // Let's not impose the re-definition of any of the athletic terms, shall we?
18}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    var deletePlanetIndexPath: NSIndexPath? = nil
 6
 7    // ...
 8
 9    func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
10        if editingStyle == .Delete {
11            deletePlanetIndexPath = indexPath
12            let planetToDelete = planets[indexPath.row]
13            confirmDelete(planetToDelete)
14        }
15    }
16
17    // ...
18}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    func confirmDelete(planet: String) {
 6        let alert = UIAlertController(title: "Delete Planet", message: "Are you sure you want to permanently delete \(planet)?", preferredStyle: .ActionSheet)
 7        
 8        let DeleteAction = UIAlertAction(title: "Delete", style: .Destructive, handler: handleDeletePlanet)
 9        let CancelAction = UIAlertAction(title: "Cancel", style: .Cancel, handler: cancelDeletePlanet)
10        
11        alert.addAction(DeleteAction)
12        alert.addAction(CancelAction)
13        
14        // Support display in iPad
15        alert.popoverPresentationController?.sourceView = self.view
16        alert.popoverPresentationController?.sourceRect = CGRectMake(self.view.bounds.size.width / 2.0, self.view.bounds.size.height / 2.0, 1.0, 1.0)
17        
18        self.presentViewController(alert, animated: true, completion: nil)
19    }
20
21    // ...
22}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    var deletePlanetIndexPath: NSIndexPath? = nil
 6
 7    // ...
 8
 9    func handleDeletePlanet(alertAction: UIAlertAction!) -> Void {
10        if let indexPath = deletePlanetIndexPath {
11            tableView.beginUpdates()
12            
13            planets.removeAtIndex(indexPath.row)
14            
15            // Note that indexPath is wrapped in an array:  [indexPath]
16            tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
17            
18            deletePlanetIndexPath = nil
19            
20            tableView.endUpdates()
21        }
22    }
23    
24    func cancelDeletePlanet(alertAction: UIAlertAction!) {
25        deletePlanetIndexPath = nil
26    }
27
28    // ...
29}

1func newAngle() -> Double {
2    return 360 * (currentCount / maxCount)
3}

1@IBAction func increaseProgressButtonTapped(sender: UIButton) {
2    if currentCount != maxCount {
3        currentCount += 1
4        let newAngleValue = newAngle()
5        
6        circularProgressView.animate(toAngle: newAngleValue, duration: 0.5, completion: nil)
7    }
8}

1@IBAction func resetButtonTapped(sender: UIButton) {
2    currentCount = 0
3    circularProgressView.animate(fromAngle: circularProgressView.angle, toAngle: 0, duration: 0.5, completion: nil)
4}

1let a = 10
2let b = 5 + 2 + 3
3a == b // true
4
5let x = 1
6let y = 2
7x == y // false

1let str1 = "I love Swift!"
2let str2 = "I love Swift!"
3str1 == str2 // true
4
5
6let str3 = "i love swift!"
7str1 == str3 // false - case-sensitive comparison

 1let x = 1
 2let y = 1
 3
 4x == y // true
 5y == x // true
 6
 7let str1 = "Hi"
 8let str2 = "Hello"
 9
10x == y // false
11y == x // false

1let x = 100
2let y = 50 + 50
3let z = 50 * 2
4
5x == y // true
6y == z // true
7x == z // true

1struct Place {
2    let name: String
3    let latitude: Double
4    let longitude: Double
5
6    // init is auto-generated by the compiler in this case
7}

1extension Place: Equatable {}
2
3func ==(lhs: Place, rhs: Place) -> Bool {
4    let areEqual = lhs.name == rhs.name &&
5        lhs.latitude == rhs.latitude &&
6        lhs.longitude == rhs.longitude
7    
8    return areEqual
9}

 1extension Place: Equatable {}
 2
 3func ==(lhs: Place, rhs: Place) -> Bool {
 4    let areEqual = lhs.name == rhs.name && 
 5            lhs.latitude == rhs.latitude &&
 6            lhs.longitude == rhs.longitude &&
 7            lhs.featureImage.isEqual(rhs.featureImage) // depends on your Type's equality semantics
 8
 9    return areEqual
10}

1extension UIColor {
2    static func colorWithRedValue(#redValue: CGFloat, greenValue: CGFloat, blueValue: CGFloat, alpha: CGFloat) -> UIColor {
3        return UIColor(red: redValue/255.0, green: greenValue/255.0, blue: blueValue/255.0, alpha: alpha)
4    }
5}

1import UIKit
2import EventKit
3
4// ...

 1// Create an Event Store instance
 2let eventStore = EKEventStore();
 3
 4// Use Event Store to create a new calendar instance
 5// Configure its title
 6let newCalendar = EKCalendar(forEntityType: .Event, eventStore: eventStore)
 7
 8// Probably want to prevent someone from saving a calendar
 9// if they don't type in a name...
10newCalendar.title = "Some Calendar Name"
11
12// Access list of available sources from the Event Store
13let sourcesInEventStore = eventStore.sources 
14
15// Filter the available sources and select the "Local" source to assign to the new calendar's
16// source property
17newCalendar.source = sourcesInEventStore.filter{
18    (source: EKSource) -> Bool in
19    source.sourceType.rawValue == EKSourceType.Local.rawValue
20}.first!
21
22// Save the calendar using the Event Store instance
23do {
24    try eventStore.saveCalendar(newCalendar, commit: true)
25    NSUserDefaults.standardUserDefaults().setObject(newCalendar.calendarIdentifier, forKey: "EventTrackerPrimaryCalendar")
26} catch {
27    let alert = UIAlertController(title: "Calendar could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
28    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
29    alert.addAction(OKAction)
30    
31    self.presentViewController(alert, animated: true, completion: nil)
32}

1newCalendar.source = sourcesInEventStore.filter{
2    (source: EKSource) -> Bool in
3    source.sourceType.rawValue == EKSourceType.Local.rawValue
4}.first!

 1// ...
 2
 3// Save the calendar using the Event Store instance
 4do {
 5    try eventStore.saveCalendar(newCalendar, commit: true)
 6    NSUserDefaults.standardUserDefaults().setObject(newCalendar.calendarIdentifier, forKey: "EventTrackerPrimaryCalendar")
 7} catch {
 8    let alert = UIAlertController(title: "Calendar could not save", message: (error as NSError).localizedDescription, preferredStyle: .Alert)
 9    let OKAction = UIAlertAction(title: "OK", style: .Default, handler: nil)
10    alert.addAction(OKAction)
11    
12    self.presentViewController(alert, animated: true, completion: nil)
13}

 1class AppDelegate: UIResponder, UIApplicationDelegate {
 2
 3    var window: UIWindow?
 4
 5
 6    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
 7        // Override point for customization after application launch.
 8        
 9        let navigationController = window?.rootViewController as! UINavigationController
10        let firstVC = navigationController.viewControllers[0] as! NameOfFirstViewController
11        // set whatever properties you might want to set
12        // such as an NSmanagedObjectContext reference
13
14        return true
15    }
16
17    // ...
18}

 1class AppDelegate: UIResponder, UIApplicationDelegate {
 2
 3    // ...
 4    if let navigationController = window?.rootViewController as? UINavigationController {
 5        if let firstVC = navigationController.viewControllers[0] as? NameOfFirstViewController {
 6            firstVC.someProperty = someValue
 7        }
 8    }
 9    // ...
10}

 1public class ViewController: UIViewController {
 2
 3    // ...
 4    override public func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
 5        
 6        let destinationVC = segue.destinationViewController as! UINavigationController
 7        let nextViewController = destinationVC.viewControllers[0] as! SecondViewController
 8        
 9        nextViewController.someProperty = someValue
10    }
11    // ...
12}

 1// MARK: NSFetchedResultsControllerDelegate methods
 2public func controllerWillChangeContent(controller: NSFetchedResultsController) {
 3    self.tableView.beginUpdates()
 4}
 5
 6public func controller(
 7    controller: NSFetchedResultsController,
 8    didChangeObject anObject: AnyObject,
 9    atIndexPath indexPath: NSIndexPath?,
10    forChangeType type: NSFetchedResultsChangeType,
11    newIndexPath: NSIndexPath?) {
12        
13        // implementation to follow...
14}
15
16public func controller(
17    controller: NSFetchedResultsController,
18    didChangeSection sectionInfo: NSFetchedResultsSectionInfo,
19    atIndex sectionIndex: Int,
20    forChangeType type: NSFetchedResultsChangeType) {
21    
22        // implementation to follow...
23}
24
25public func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String) -> String? {
26    return sectionName
27}
28
29public func controllerDidChangeContent(controller: NSFetchedResultsController) {
30    self.tableView.endUpdates()
31}

 1public func controller(
 2        controller: NSFetchedResultsController,
 3        didChangeObject anObject: AnyObject,
 4        atIndexPath indexPath: NSIndexPath?,
 5        forChangeType type: NSFetchedResultsChangeType,
 6        newIndexPath: NSIndexPath?) {
 7            
 8            switch type {
 9            case NSFetchedResultsChangeType.Insert:
10                // Note that for Insert, we insert a row at the __newIndexPath__
11                if let insertIndexPath = newIndexPath {
12                    self.tableView.insertRowsAtIndexPaths([insertIndexPath], withRowAnimation: UITableViewRowAnimation.Fade)
13                }
14            case NSFetchedResultsChangeType.Delete:
15                // Note that for Delete, we delete the row at __indexPath__
16                if let deleteIndexPath = indexPath {
17                    self.tableView.deleteRowsAtIndexPaths([deleteIndexPath], withRowAnimation: UITableViewRowAnimation.Fade)
18                }
19            case NSFetchedResultsChangeType.Update:
20                if let updateIndexPath = indexPath {
21                    // Note that for Update, we update the row at __indexPath__
22                    let cell = self.tableView.cellForRowAtIndexPath(updateIndexPath)
23                    let animal = self.fetchedResultsController.objectAtIndexPath(updateIndexPath) as? Animal
24                    
25                    cell?.textLabel?.text = animal?.commonName
26                    cell?.detailTextLabel?.text = animal?.habitat
27                }
28            case NSFetchedResultsChangeType.Move:
29                // Note that for Move, we delete the row at __indexPath__
30                if let deleteIndexPath = indexPath {
31                    self.tableView.deleteRowsAtIndexPaths([deleteIndexPath], withRowAnimation: UITableViewRowAnimation.Fade)
32                }
33                
34                // Note that for Move, we insert a row at the __newIndexPath__
35                if let insertIndexPath = newIndexPath {
36                    self.tableView.insertRowsAtIndexPaths([insertIndexPath], withRowAnimation: UITableViewRowAnimation.Fade)
37                }
38            }
39}

 1public func controller(
 2    controller: NSFetchedResultsController,
 3    didChangeSection sectionInfo: NSFetchedResultsSectionInfo,
 4    atIndex sectionIndex: Int,
 5    forChangeType type: NSFetchedResultsChangeType) {
 6    
 7        switch type {
 8        case .Insert:
 9            let sectionIndexSet = NSIndexSet(index: sectionIndex)
10            self.tableView.insertSections(sectionIndexSet, withRowAnimation: UITableViewRowAnimation.Fade)
11        case .Delete:
12            let sectionIndexSet = NSIndexSet(index: sectionIndex)
13            self.tableView.deleteSections(sectionIndexSet, withRowAnimation: UITableViewRowAnimation.Fade)
14        default:
15            ""
16        }
17}
18
19public func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String?) -> String? {
20    return sectionName
21}

1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
2
3    let eventStore = EKEventStore()
4
5    // ...    
6}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4    
 5    override func viewWillAppear(animated: Bool) {
 6        checkCalendarAuthorizationStatus()
 7    }
 8    
 9    func checkCalendarAuthorizationStatus() {
10        let status = EKEventStore.authorizationStatus(for: EKEntityType.event)
11        
12        switch (status) {
13        case EKAuthorizationStatus.notDetermined:
14            // This happens on first-run
15            requestAccessToCalendar()
16        case EKAuthorizationStatus.authorized:
17            // Things are in line with being able to show the calendars in the table view
18            loadCalendars()
19            refreshTableView()
20        case EKAuthorizationStatus.restricted, EKAuthorizationStatus.denied:
21            // We need to help them give us permission
22            needPermissionView.fadeIn()
23        }
24    }
25
26    // ...
27}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3   // ...
 4   
 5    func requestAccessToCalendar() {
 6        eventStore.requestAccess(to: EKEntityType.event, completion: {
 7            (accessGranted: Bool, error: Error?) in
 8            
 9            if accessGranted == true {
10                DispatchQueue.main.async(execute: {
11                    self.loadCalendars()
12                    self.refreshTableView()
13                })
14            } else {
15                DispatchQueue.main.async(execute: {
16                    self.needPermissionView.fadeIn()
17                })
18            }
19        })
20    }
21
22    // ...
23}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    var calendars: [EKCalendar]?
 6
 7    // ...
 8    
 9    func loadCalendars() {
10        self.calendars = eventStore.calendars(for: EKEntityType.event)
11    }
12    
13    func refreshTableView() {
14        calendarsTableView.isHidden = false
15        calendarsTableView.reloadData()
16    }
17
18    // ...
19}

 1class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 2
 3    // ...
 4
 5    @IBAction func goToSettingsButtonTapped(_ sender: UIButton) {
 6        let openSettingsUrl = URL(string: UIApplicationOpenSettingsURLString)
 7        UIApplication.shared.openURL(openSettingsUrl!)
 8    }
 9
10    // ...
11}

 1class Animal {
 2    let name: String
 3    let species: String
 4    init(name: String, species: String) { 
 5        self.name = name
 6        self.species = species
 7    }
 8
 9    var exhibit: Exhibit?  // notice the optional nature of exhibit
10}
11 
12class Exhibit {
13    let title: String
14    init(title: String) { self.title = title }
15
16    var animal: Animal? // notice the optional nature of animal
17}

 1class Animal {
 2    let name: String
 3    let species: String
 4    init(name: String, species: String) { 
 5        self.name = name
 6        self.species = species
 7    }
 8
 9    var exhibit: Exhibit?  // we'll hold a strong reference to the exhibit
10}
11 
12class Exhibit {
13    let title: String
14    init(title: String) { self.title = title }
15
16    weak var animal: Animal? // but notice - we're holding a _weak_ reference to the animal
17}

 1class Visitor {
 2    let name: String
 3    var annualPass: AnnualPass?
 4    init(name: String) {
 5        self.name = name
 6    }
 7}
 8 
 9class AnnualPass {
10    let number: UInt64
11    unowned let passholder: Visitor // notice the use of an _unowned_ reference
12    init(number: UInt64, passholder: Visitor) {
13        self.number = number
14        self.passholder = passholder
15    }
16}

1private struct Person {
2    private let name: String
3}
4
5private struct Greeter {
6    private func greet(person: Person) {
7        println("Hi, I'm \(person.name)")
8    }
9}

 1public struct Person {
 2    private var name: String
 3    private var gender: Gender
 4    private var age: Int
 5    
 6    public init(name: String, gender: Gender, age: Int) {
 7        self.name = name
 8        self.gender = gender
 9        self.age = age
10    }
11    
12    public func howOldAreYou() -> String {
13        return formattedAge()
14    }
15    
16    // private func, simply to show extension visibility traits in the analysis below...
17    private func formattedAge() -> String {
18        switch self.gender {
19        case .Male:
20            return "I'm \(self.age)."
21        case .Female:
22            return "Not telling."
23        }
24    }
25    
26    public enum Gender {
27        case Male
28        case Female
29    }
30}

1extension Person {
2    func getAge() -> Int {
3        return age // compiles, even though age is --private--
4    }
5    
6    func getFormattedAge() -> String {
7        return formattedAge() // compiles, even though formattedAge is --private--
8    }
9}

 1public struct Person {
 2    // ...
 3    
 4    // ...
 5}
 6
 7extension Person {
 8    func getAge() -> Int {
 9        return age
10    }
11    
12    func getFormattedAge() -> String {
13        return formattedAge()
14    }
15}

 1// Instead of this (default --internal-- access)...
 2class MyClass {
 3    func myFunc() {
 4        // Performs something essential to why MyClass exists
 5    }
 6}
 7
 8// Make things public...
 9public class MyClass {
10    public func myFunc() {
11        // Performs something essential to why MyClass exists
12    }
13}

1protocol RatingPickerDelegate {
2    func preferredRatingSymbol(picker: RatingPicker) -> UIImage?
3    func didSelectRating(picker: RatingPicker, rating: Int)
4    func didCancel(picker: RatingPicker)
5}

 1// Disclaimer:  There is much more logic that would go into a real UIView subclass or a picker control in real life
 2// This example is contrived and is only meant to serve as a "shell" of what code could look like
 3// that uses a delegate within its implementation
 4
 5class RatingPicker {
 6    weak var delegate: RatingPickerDelegate?
 7    
 8    init(withDelegate delegate: RatingPickerDelegate?) {
 9        self.delegate = delegate
10    }
11 
12    func setup() {
13        let preferredRatingSymbol = delegate?.preferredRatingSymbol(picker: self)
14        
15        // Set up the picker with the preferred rating symbol if it was specified
16    }
17    
18    func selectRating(selectedRating: Int) {
19        delegate?.didSelectRating(picker: self, rating: selectedRating)
20        // Other logic related to selecting a rating
21    }
22    
23    func cancel() {
24        delegate?.didCancel(picker: self)
25        // Other logic related to canceling
26    }
27}

 1class RatingPickerHandler: RatingPickerDelegate {
 2    func preferredRatingSymbol(picker: RatingPicker) -> UIImage? {
 3        return UIImage(contentsOfFile: "Star.png")
 4    }
 5    
 6    func didSelectRating(picker: RatingPicker, rating: Int) {
 7        // do something in response to a rating being selected
 8    }
 9    
10    func didCancel(picker: RatingPicker) {
11        // do something in response to the rating picker canceling
12    }
13}

1public enum SubscriberStatus {
2    case CurrentSubscriber
3    case ExpiredSubscriber
4    case NonSubscriber
5}

 1func checkSubscriberStatusForRegistrant(registrant: Registrant) {
 2    // We're coming to the definition of Registrant...
 3    // In fact, Registrant's implementation is the goal of this blog entry!
 4
 5    switch (registrant.subscriberStatus) {
 6    case .CurrentSubscriber:
 7        showPremiumContent()
 8    case .ExpiredSubscriber:
 9        alertExpiredSubscription()
10    case .NonSubscriber:
11        offerSubscription()
12    }
13    
14}

 1public struct Registrant {
 2    public var subscriberStatus: SubscriberStatus {
 3        get {
 4            if (noSubscriptionOnFile()) {
 5                return .NonSubscriber
 6            }
 7            
 8            if (subscriptionOverdueForPayment()) {
 9                return .ExpiredSubscriber
10            }
11            
12            return .CurrentSubscriber
13        }
14    }
15    
16    private func noSubscriptionOnFile() -> Bool {
17        // Do what needs to be done to check if the registrant has a subscription on file or not
18    }
19    
20    private func subscriptionOverdueForPayment() -> Bool {
21        // Do what needs to be done to check if the registrant's subscription is overdue for payment
22    }
23}

<li>
  <i class="fab fa-github fa-lg"></i> Example implemented with regular view controller + UITableView <div>
    (<a href="https://github.com/andrewcbancroft/PullToRefreshExample_RegularViewController/tree/swift-2.3">Swift 2.3</a> | <a href="https://github.com/andrewcbancroft/PullToRefreshExample_RegularViewController/tree/master">Swift 3.0</a>)
  </div>
</li>

1struct Movie {
2    let title: String
3    let genre: String
4}

1var movies = [
2    Movie(title: "Lion King", genre: "Animation"),
3    Movie(title: "Star Wars", genre: "Sci-fi")
4]

 1override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
 2    return movies.count
 3}
 4
 5override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
 6    let cell = tableView.dequeueReusableCell(withIdentifier: "cell")!
 7    
 8    cell.textLabel?.text = movies[(indexPath as NSIndexPath).row].title
 9    cell.detailTextLabel?.text = movies[(indexPath as NSIndexPath).row].genre
10    
11    return cell
12}

1override func viewDidLoad() {
2    super.viewDidLoad()
3    // Do any additional setup after loading the view, typically from a nib.
4    
5    self.refreshControl?.addTarget(self, action: #selector(ViewController.handleRefresh(_:)), for: UIControlEvents.valueChanged)
6}

 1func handleRefresh(refreshControl: UIRefreshControl) {
 2    // Do some reloading of data and update the table view's data source
 3    // Fetch more objects from a web service, for example...
 4    
 5    // Simply adding an object to the data source for this example
 6    let newMovie = Movie(title: "Serenity", genre: "Sci-fi")
 7    movies.append(newMovie)
 8    
 9    movies.sort() { $0.title < $1.title }
10    
11    self.tableView.reloadData()
12    refreshControl.endRefreshing()
13}

 1 Int {
 2    return movies.count
 3}
 4
 5func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
 6    let cell = tableView.dequeueReusableCell(withIdentifier: "cell")!
 7    
 8    cell.textLabel?.text = movies[(indexPath as NSIndexPath).row].title
 9    cell.detailTextLabel?.text = movies[(indexPath as NSIndexPath).row].genre
10    
11    return cell
12}

1lazy var refreshControl: UIRefreshControl = {
2    let refreshControl = UIRefreshControl()
3    refreshControl.addTarget(self, action: #selector(ViewController.handleRefresh(_:)), for: UIControlEvents.valueChanged)
4    
5    return refreshControl
6}()

1override func viewDidLoad() {
2    super.viewDidLoad()
3    // Do any additional setup after loading the view, typically from a nib.
4    
5    self.tableView.addSubview(self.refreshControl)
6}

 1func handleRefresh(refreshControl: UIRefreshControl) {
 2    // Do some reloading of data and update the table view's data source
 3    // Fetch more objects from a web service, for example...
 4    
 5    // Simply adding an object to the data source for this example
 6    let newMovie = Movie(title: "Serenity", genre: "Sci-fi")
 7    movies.append(newMovie)
 8    
 9    movies.sort() { $0.title < $1.title }
10    
11    self.tableView.reloadData()
12    refreshControl.endRefreshing()
13}

1
2
3
4
5
6
7
8

public class MainViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, NSFetchedResultsControllerDelegate {

    // maintain a reference to NSManagedObjectContext instance

    // create and configure an NSFetchedResultsController instance

    // Implement UITableViewDataSource methods
}
1
2
3
4
5
6

public class MainViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, NSFetchedResultsControllerDelegate {

    public var context: NSManagedObjectContext!

    // ...
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class MainViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, NSFetchedResultsControllerDelegate {

    // ...

    lazy var fetchedResultsController: NSFetchedResultsController = {
        let animalsFetchRequest = NSFetchRequest(entityName: "Animal")
        let primarySortDescriptor = NSSortDescriptor(key: "classification.order", ascending: true)
        let secondarySortDescriptor = NSSortDescriptor(key: "commonName", ascending: true)
        animalsFetchRequest.sortDescriptors = [primarySortDescriptor, secondarySortDescriptor]

        let frc = NSFetchedResultsController(
            fetchRequest: animalsFetchRequest,
            managedObjectContext: self.context,
            sectionNameKeyPath: "classification.order",
            cacheName: nil)

        frc.delegate = self

        return frc
        }()

    // ...

}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class MainViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, NSFetchedResultsControllerDelegate {

    // ...

    override public func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

            do {
                try fetchedResultsController.performFetch()
            } catch {
                print("An error occurred")
            }
    }

    // ...

}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public class MainViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, NSFetchedResultsControllerDelegate {

    // ...

    // MARK: TableView Data Source
    public func numberOfSectionsInTableView(tableView: UITableView) -> Int {
        if let sections = fetchedResultsController.sections {
            return sections.count
        }

        return 0
    }

    public func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        if let sections = fetchedResultsController.sections {
            let currentSection = sections[section] 
            return currentSection.numberOfObjects
        }

        return 0
    }

    public func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCellWithIdentifier("Cell", forIndexPath: indexPath) 
        let animal = fetchedResultsController.objectAtIndexPath(indexPath) as! Animal

        cell.textLabel?.text = animal.commonName
        cell.detailTextLabel?.text = animal.habitat

        return cell
    }

    public func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
        if let sections = fetchedResultsController.sections {
            let currentSection = sections[section] 
            return currentSection.name
        }

        return nil
    }

    // ...

}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class AppDelegate: UIResponder, UIApplicationDelegate {

    // ...

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        // Override point for customization after application launch.

        let dataHelper = DataHelper(context: self.managedObjectContext)
        dataHelper.seedDataStore()

        dataHelper.printAllZoos()
        dataHelper.printAllClassifications()
        dataHelper.printAllAnimals()

        let rootViewController = self.window!.rootViewController as! MainViewController
        rootViewController.context = self.managedObjectContext;

        return true
    }

    // ...

}
 1public class DataHelper {
 2    let context: NSManagedObjectContext
 3    
 4    init(context: NSManagedObjectContext) {
 5        self.context = context
 6    }
 7    
 8// ...
 9
10}

 1public class DataHelper {
 2
 3// ...
 4
 5    private func seedZoos() {
 6        let zoos = [
 7            (name: "Oklahoma City Zoo", location: "Oklahoma City, OK"),
 8            (name: "Lowry Park Zoo", location: "Tampa, FL"),
 9            (name: "San Diego Zoo", location: "San Diego, CA")
10        ]
11        
12        for zoo in zoos {
13            let newZoo = NSEntityDescription.insertNewObjectForEntityForName("Zoo", inManagedObjectContext: context) as! Zoo
14            newZoo.name = zoo.name
15            newZoo.location = zoo.location
16        }
17        
18        do {
19            try context.save()
20        } catch _ {
21        }
22    }
23
24// ...
25
26}

 1public class DataHelper {
 2
 3// ...
 4
 5    public func printAllZoos() {
 6        let zooFetchRequest = NSFetchRequest(entityName: "Zoo")
 7        let primarySortDescriptor = NSSortDescriptor(key: "name", ascending: true)
 8        
 9        zooFetchRequest.sortDescriptors = [primarySortDescriptor]
10        
11        let allZoos = (try! context.executeFetchRequest(zooFetchRequest)) as! [Zoo]
12        
13        for zoo in allZoos {
14            print("Zoo Name: \(zoo.name)\nLocation: \(zoo.location) \n-------\n", terminator: "")
15        }
16    }
17
18// ...
19
20}

 1public class DataHelper {
 2
 3// ...
 4
 5    private func seedAnimals() {
 6        // Grab Classifications
 7        let classificationFetchRequest = NSFetchRequest(entityName: "Classification")
 8        let allClassifications = (try! context.executeFetchRequest(classificationFetchRequest)) as! [Classification]
 9
10        let manatee = allClassifications.filter({(c: Classification) -> Bool in
11            return c.family == "Trichechidae"
12        }).first
13        
14        // Same pattern for monkey and bat
15        
16        // Grab Zoos
17        let zooFetchRequest = NSFetchRequest(entityName: "Zoo")
18        let allZoos = (try! context.executeFetchRequest(zooFetchRequest)) as! [Zoo]
19        
20        let oklahomaCityZoo = allZoos.filter({ (z: Zoo) -> Bool in
21            return z.name == "Oklahoma City Zoo"
22        }).first
23        
24        // Same pattern for San Diego Zoo and Lowry Park Zoo
25        
26        // Create an array of "animal" tuples, assigning
27        // whatever Classification and Zoo make sense
28        let animals = [
29            (commonName: "Pygmy Fruit-eating Bat", habitat: "Flying Mamals Exhibit", classification: bat!, zoos: NSSet(array: [lowryParkZoo!, oklahomaCityZoo!, sanDiegoZoo!])),
30            (commonName: "Mantled Howler", habitat: "Primate Exhibit", classification: monkey!, zoos: NSSet(array: [sanDiegoZoo!, lowryParkZoo!])),
31            (commonName: "Geoffroy’s Spider Monkey", habitat: "Primate Exhibit", classification: monkey!, zoos: NSSet(array: [sanDiegoZoo!])),
32            (commonName: "West Indian Manatee", habitat: "Aquatic Mamals Exhibit", classification: manatee!, zoos: NSSet(array: [lowryParkZoo!]))
33        ]
34        
35        // Create -actual- Animal instances and insert them
36        for animal in animals {
37            let newAnimal = NSEntityDescription.insertNewObjectForEntityForName("Animal", inManagedObjectContext: context) as! Animal
38            newAnimal.commonName = animal.commonName
39            newAnimal.habitat = animal.habitat
40            newAnimal.classification = animal.classification
41            newAnimal.zoos = animal.zoos
42        }
43        
44        do {
45            try context.save()
46        } catch _ {
47        }
48    }
49
50// ...
51
52}

 1func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
 2        // Override point for customization after application launch.
 3        
 4        let dataHelper = DataHelper(context: self.managedObjectContext)
 5        dataHelper.seedDataStore()
 6        
 7        dataHelper.printAllZoos()
 8        dataHelper.printAllClassifications()
 9        dataHelper.printAllAnimals()
10        
11        return true
12    }

 1lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
 2        // The persistent store coordinator for the application. This implementation creates and returns a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.
 3        // Create the coordinator and store
 4        let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
 5        let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("Zootastic.sqlite")
 6        
 7        do {
 8            try NSFileManager.defaultManager().removeItemAtURL(url)
 9        } catch _ {
10        }
11
12        
13        var failureReason = "There was an error creating or loading the application's saved data."
14        do {
15            try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
16        } catch {
17            // Report any error we got.
18            var dict = [String: AnyObject]()
19            dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
20            dict[NSLocalizedFailureReasonErrorKey] = failureReason
21            
22            dict[NSUnderlyingErrorKey] = error as NSError
23            let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
24            // Replace this with code to handle the error appropriately.
25            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
26            NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
27            abort()
28        }
29        
30        return coordinator
31        }()
1
2
3
4
5
6
7
8
9

// Assuming type has a reference to managed object context

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]
    // Do something with fetchedEntities
} catch {
    // Do something in response to error condition
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Assuming type has a reference to managed object context

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
fetchRequest.fetchLimit = 10
do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]
    // Do something with fetchedEntities
} catch {
    // Do something in response to error condition
}   
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Assuming encapsulating Type has a reference to managed object context

let newEntity = NSEntityDescription.insertNewObjectForEntityForName("MyEntity", inManagedObjectContext: self.managedObjectContext) as! MyEntity
// Set properties

do {
    try self.managedObjectContext.save()
} catch {
    // Do something in response to error condition
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Assuming type has a reference to managed object context

// Assuming that a specific NSManagedObject's objectID property is accessible
// Alternatively, could supply a predicate expression that's precise enough
// to select only a _single_ entity
let predicate = NSPredicate(format: "objectID == %@", objectIDFromNSManagedObject)

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
fetchRequest.predicate = predicate

do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]
    fetchedEntities.first?.FirstPropertyToUpdate = NewValue
    fetchedEntities.first?.SecondPropertyToUpdate = NewValue
    // ... Update additional properties with new values
} catch {
    // Do something in response to error condition
}

do {
    try self.managedObjectContext.save()
} catch {
    // Do something in response to error condition
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Assuming type has a reference to managed object context

let predicate = NSPredicate(format: "MyEntityAttribute == %@", "Matching Value")

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
fetchRequest.predicate = predicate

do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]

    for entity in fetchedEntities {
        entity.FirstPropertyToUpdate = NewValue
        entity.SecondPropertyToUpdate = NewValue
        // ... Update additional properties with new values
    }
} catch {
    // Do something in response to error condition
}

do {
    try self.managedObjectContext.save()
} catch {
    // Do something in response to error condition
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Assuming type has a reference to managed object context

// Assuming that a specific NSManagedObject's objectID property is accessible
// Alternatively, could supply a predicate expression that's precise enough
// to select only a _single_ entity
let predicate = NSPredicate(format: "objectID == %@", objectIDFromNSManagedObject)

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
fetchRequest.predicate = predicate

do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]
    if let entityToDelete = fetchedEntities.first {
        self.managedObjectContext.deleteObject(entityToDelete)
    }
} catch {
    // Do something in response to error condition
}

do {
    try self.managedObjectContext.save()
} catch {
    // Do something in response to error condition
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Assuming type has a reference to managed object context

let predicate = NSPredicate(format: "MyEntityAttribute == %@", "Matching Value")

let fetchRequest = NSFetchRequest(entityName: "MyEntity")
fetchRequest.predicate = predicate

do {
    let fetchedEntities = try self.managedObjectContext.executeFetchRequest(fetchRequest) as! [MyEntity]

    for entity in fetchedEntities {
        self.managedObjectContext.deleteObject(entity)
    }
} catch {
    // Do something in response to error condition
}

do {
    try self.managedObjectContext.save()
} catch {
    // Do something in response to error condition
}
1
2
3
4
5
6

let model = // set up model

let pscOptions = [NSMigratePersistentStoresAutomaticallyOption : true, NSInferMappingModelAutomaticallyOption : true]

let psc = NSPersistentStoreCoordinator(managedObjectModel: model)
try! psc.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: pscOptions)
 1import UIKit
 2
 3public class TextInputTableViewCell: UITableViewCell {
 4    @IBOutlet weak var textField: UITextField!
 5    
 6    public func configure(#text: String?, placeholder: String) {
 7        textField.text = text
 8        textField.placeholder = placeholder
 9        
10        textField.accessibilityValue = text
11        textField.accessibilityLabel = placeholder
12    }
13}

 1import UIKit
 2
 3public class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
 4    public func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
 5        return 1 // Create 1 row as an example
 6    }
 7 
 8    public func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
 9        let cell = tableView.dequeueReusableCellWithIdentifier("TextInputCell") as TextInputTableViewCell
10        
11        cell.configure(text: "", placeholder: "Enter some text!")
12        return cell
13    }
14}

#define SQUARE_NUMBER(n) n * n
```

One thing we could do is write a function that produces the same thing:

```swift
func squareNumber(n: Int) -> Int {
    return n * n
}
```

### A little more complicated

An example situation that came to me on Twitter took the form of converting a macro that was a little more complicated than the simple example just presented. The input to the complex macro was a color, represented as a hexadecimal value, along with an alpha, represented as a float. The output? A `UIColor` instance based on some bitwise manipulations to that hex value.

I've created a GitHub example if you'd like to play around with everything. The relevant code is reproduced below…

    Resources

       Example Xcode Project

The macro form looked like this:

#define UIColorFromRGB(rgbValue, alphaValue) \
[UIColor colorWithRed:((float)((rgbValue >> 16) & 0xFF))/255.0 \
green:((float)((rgbValue >> 8) & 0xFF))/255.0 \
blue:((float)((rgbValue >> 0) & 0xFF))/255.0 \
alpha:alphaValue]
```

Rewriting it as a Swift function:

```swift
func UIColorFromRGB(rgb: Int, alpha: Float) -> UIColor {
    let red = CGFloat(Float(((rgb>>16) & 0xFF)) / 255.0)
    let green = CGFloat(Float(((rgb>>8) & 0xFF)) / 255.0)
    let blue = CGFloat(Float(((rgb>>0) & 0xFF)) / 255.0)
    let alpha = CGFloat(alpha)

    return UIColor(red: red, green: green, blue: blue, alpha: alpha)
}
```

The main thing to keep in mind is that the output of the macro/function is the focus. The internals could change to better-adapt to Swift's features if you desire. If the macro was ugly inside, make it nice in Swift!

### Where should the function go?

  * For organization's sake, you could create a new .swift file and place the function inside it at the global level. This would provide the most convenient transition for your Objective-C to Swift conversion, because `#defines` were available wherever you imported the Objective-C header file.
  * Alternatively, you could encapsulate the function in a class/struct/enum.

### Wrapping up

With the power of Swift functions and the ability to even declare and use them globally, converting complex macros to a better Swift alternative is much less daunting than you might expect.

 [1]: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithCAPIs.html#//apple_ref/doc/uid/TP40014216-CH8-XID_20
 [2]: http://www.andrewcbancroft.com/2014/10/01/swift-alternative-to-objective-c-macros/
 [3]: http://www.andrewcbancroft.com/wp-content/uploads/2015/01/complex_macros.png

 1class Scorekeeper {
 2    let runningScore: Int
 3    let climbingScore: Int
 4    // potentially more properties
 5    
 6    init(runningScore: Int = 0, climbingScore: Int = 0) {
 7        self.runningScore = runningScore
 8        self.climbingScore = climbingScore
 9    }
10    
11    // second helper initializer
12    init(scoreKeeper: Scorekeeper, runningScore: Int? = nil, climbingScore: Int? = nil) {
13        self.runningScore = runningScore ?? scoreKeeper.runningScore
14        self.climbingScore = climbingScore ?? scoreKeeper.climbingScore
15    }
16    
17    func incrementRunningScoreBy(points: Int) -> Scorekeeper {
18        return Scorekeeper(scoreKeeper: self, runningScore: self.runningScore + points)
19    }
20    
21    // other functions to transform Scorekeeper by incrementing other score properties
22}

 1import CoreData
 2
 3func setUpInMemoryManagedObjectContext() -> NSManagedObjectContext {
 4    let managedObjectModel = NSManagedObjectModel.mergedModelFromBundles([NSBundle.mainBundle()])!
 5    
 6    let persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: managedObjectModel)
 7
 8    do {
 9        try persistentStoreCoordinator.addPersistentStoreWithType(NSInMemoryStoreType, configuration: nil, url: nil, options: nil)
10    } catch {
11        print("Adding in-memory persistent store failed")
12    }
13    
14    let managedObjectContext = NSManagedObjectContext()
15    managedObjectContext.persistentStoreCoordinator = persistentStoreCoordinator
16    
17    return managedObjectContext
18}

 1import CoreData
 2
 3class TestsUsingModelFromCoreData: XCTestCase {
 4    func testSomethingUsingCoreData() {
 5        let managedObjectContext = setUpInMemoryManagedObjectContext()
 6        let entity = NSEntityDescription.insertNewObjectForEntityForName("EntityName", inManagedObjectContext: managedObjectContext)
 7        
 8        // model setup
 9        
10        // XCTAssert    
11    }
12}

class Scorekeeper {
    var runningScore: Int

    init (score: Int = 0) {
        self.runningScore = score
    }

    func incrementScoreBy(points: Int) {
        runningScore += points
    }
}

let scoreKeeper = Scorekeeper()
scoreKeeper.incrementScoreBy(5)
println(scoreKeeper.runningScore)
// prints 5

    <p></p>

    ### The immutable way

    OR, rather than mutating the existing variable, we could go an alternate route:  The second way to design the class is to declare a constant stored property.  The method would then produce _new_ instance that stored the new state:

        class Scorekeeper {
            let runningScore: Int

            init (score: Int = 0) {
                self.runningScore = score
            }

            func incrementScoreBy(points: Int) -> Scorekeeper {
                return Scorekeeper(score: self.runningScore + points)
            }
        }

        let scorekeeper = Scorekeeper()
        let scorekeeperWithIncreasedScore = scorekeeper.incrementScoreBy(5)
        println(scorekeeperWithIncreasedScore.runningScore)
        // prints 5

    <p></p>

    ### Observations

    As I look at the code I've just presented, I notice a few things as I contrast the two examples:

      * The first example uses var to declare the stored property of my Scorekeeper class.  It _has_ to be var so that the value of the property can be changed (mutated).

      * The second example uses let exclusively.  No in-place mutations occur, so constants are perfectly reasonable to use.

    * * *

      * The first example's design lends itself to produce interesting and unpredictable side-effects.  If multiple clients hold a reference to my scorekeeper instance, there are two ways for the runningScore to change out from underneath any of those clients:  First, I could simply reassign a value to the runningScore directly.  Second, I could call incrementScoreBy().  Either way, unintended consequences may arise because of the mutation.

      * In the second example, it's _impossible_ to cause those unintended consequences.  runningScore can't be changed directly (it's a constant), and incrementScoreBy() returns a whole _new_ instance, so all clients would be dealing with the instance that they expect to be dealing with.  No values can be changed out from underneath them.

    * * *

      * The first example's incrementScoreBy method has no return value.  While I can envision writing a unit test for this, it's not obvious at first glance what I should do.  The method produces a side-effect in my existing instance that I need to know about in order to get the XCTAssert right.

      * The second example's incrementScoreBy method returns a new Scorekeeper instance.  The unit test for this (to me) is a little more clear.  I simply inspect the value of runningScore of the new instance, and assert that it is [x] points higher than the old instance.  I still have both the old scorekeeper instance _and_ the new scorekeeperWithIncreasedScore, so everything I'd need to ensure the correct point increase occurred is at my disposal.

    ### Conclusion

    I hear so much benefit that comes from avoiding mutable state, so it was satisfying to finally let my mind reconcile how to manage the state of my own Types immutably.  With the iOS frameworks we have to work with, immutability is a challenge, and _total_ immutable state is not possible (think of the user interface layer where state is stored and updated out of necessity because of how _Apple's_ frameworks and tools are designed). Nonetheless, I found this discovery to be really exciting all the same.

DealershipName	RedCars	SilverCars	BlackCars	BlueCars	MonthSold	YearSold
Clyde's Clunkers	902	650	754	792	1	2018
Clyde's Clunkers	710	476	518	492	2	2018
Clyde's Clunkers	248	912	606	350	3	2018
Clyde's Clunkers	782	912	858	446	4	2018
Clyde's Clunkers	278	354	482	752	5	2018

DealershipName	RedCars	SilverCars	BlackCars	BlueCars	MonthSold	YearSold
Clyde's Clunkers	902	650	754	792	1	2018
Clyde's Clunkers	710	476	518	492	2	2018
Clyde's Clunkers	248	912	606	350	3	2018
Clyde's Clunkers	782	912	858	446	4	2018
Clyde's Clunkers	278	354	482	752	5	2018

	DealershipName	RedCars	SilverCars	BlackCars	BlueCars	MonthSold	YearSold
0	Clyde's Clunkers	902.0	650.0	754.0	792.0	1.0	2018.0
1	Clyde's Clunkers	710.0	476.0	518.0	492.0	2.0	2018.0
2	Clyde's Clunkers	248.0	912.0	606.0	350.0	3.0	2018.0
3	Clyde's Clunkers	782.0	912.0	858.0	446.0	4.0	2018.0
4	Clyde's Clunkers	278.0	354.0	482.0	752.0	5.0	2018.0

	DealershipName	RedCars	SilverCars	BlackCars	BlueCars	MonthSold	YearSold
0	Clyde's Clunkers	902	650	754	792	1	2018
1	Clyde's Clunkers	710	476	518	492	2	2018
2	Clyde's Clunkers	248	912	606	350	3	2018
3	Clyde's Clunkers	782	912	858	446	4	2018
4	Clyde's Clunkers	278	354	482	752	5	2018

	DealershipName	RedCars	SilverCars	BlackCars	BlueCars	MonthSold	YearSold
0	Clyde's Clunkers	902	650	754	792	1	2018
1	Clyde's Clunkers	710	476	518	492	2	2018
2	Clyde's Clunkers	248	912	606	350	3	2018
3	Clyde's Clunkers	782	912	858	446	4	2018
4	Clyde's Clunkers	278	354	482	752	5	2018

Andrew Bancroft

How I Learned to Copy and Paste, and Why I Never Do

Download macOS Beta Installer

Step 1: Turn on Beta Updates

Step 2: Use Terminal to download the installer

Step 3: Find the installer in your Applications folder

SwiftUI Fundamentals

Course Outline

1 - Building Single-view Applications

2 - Customizing UI Appearance

3 - Creating Data-driven Lists

4 - Building iOS Apps with Multiple Screens

5 - Adding Behavior and Working With Data

6 - Putting It All Together

iOS 17 Fundamentals

Course Outline

1 - Preparing to Build iOS 17 Applications

2 - Designing Applications for iOS 17

3 - Performing Common Networking Tasks

4 - Managing Data

5 - Adding Push Notification Support

6 - Implementing Widgets

7 - Publishing to the App Store

Pre-populate a SwiftData Persistent Store

Building Blocks

Initialize a ModelContainer

Initialize instances of your @Model class(es)

Insert those model instances into your ModelContainer’s mainContext

Where do you write all this code?

For your production app

For an Xcode preview

For your unit tests

Add SwiftData to an Existing App

System Configuration

Essential Pieces of SwiftData

Import SwiftData

The @Model macro

The .modelContainer() View modifier

The @Query property wrapper

The @Environment(\.modelContext) property wrapper

Wrapping Up

Building iOS User Interfaces with SwiftUI

Course Outline

1 - Designing Interfaces with SwiftUI

2 - Handling User Input

3 - Bringing Apps to Life with Drawing, Animation, and Gestures

4 - Integrating SwiftUI and UIKit

Feedback Welcome!

Swift Five - Week of February 14, 2021

Persistence prevails: Dave shares his iOS developer journey

CoreML brings the beauty of braille to the seeing

Streamlined XCTestCase Template

Kent Beck on the goal of software design

Ship something. Anything.

How to Download Old Versions of Xcode

Whyyy would I need an old version of Xcode?

How to download

iOS 14 Getting Started

Course Outline

1 – Preparing to Build iOS Applications

2 - Building Single View Applications

3 - Creating Data-driven Lists

4 - Building iOS Apps with Multiple Screens

5 - Adding Behavior and Working With Data

6 - Putting It All Together

7 - Publishing to the App Store

Feedback Welcome!

What Are All of the Possible Environment Keys in SwiftUI?

WWDC - The Worldwide Developer Community

WWDC - The Worldwide Developer Chase

WWDC - The Worldwide Developer Community

StoreKit Testing Swift Start

Manually Testing StoreKit Code

Development Workflow Changes

Making Test Purchases

Development Workflow Enhancements

StoreKit Transaction Manager

Test Edge Cases

Auto-Renewable Subscription Testing Enhancements

Automated Testing for StoreKit Code

Initialize a `ModelContainer`

Initialize instances of your `@Model` class(es)

Insert those model instances into your `ModelContainer`’s `mainContext`

The `@Model` macro

The `.modelContainer()` View modifier

The `@Query` property wrapper

The `@Environment(\.modelContext)` property wrapper