Core Data is an object design, management, and persistence framework.

A object graph is either an entity object (simple) or entity object collection (complex).

In our apps, we are always using objects and collections of objects, in memory.

An important component is the stack, which has the code that sets up and configures Core Data for the app. Most of this code is static, and will not need changes or editing.

One of the important objects that gets configured is the context (or more fully, the managed object context). We use the context everywhere in our app (data model manager, controllers). It is a work area for objects that are in memory.

1. The context supports typical operations like fetch (from the persistent store), add new (programmatically), edit existing, and delete item.


Data to-and-from the Core Data store is done with fetch request objects. Conceptually, they’re similar to the recently learned web API request objects, in that they enable data service operations (e.g. fetch, add, change, etc.).

let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
to perform fetch its context.fetch(fetchRequest)

A fetch request will return a typed array of results.

to save, its context.save()

Finally, when we’re working with a table view controller, we use a wrapper around a fetch request, known as a fetched results controller.

Core Data is like a database

1. In an app, the presence of a Core Data “stack” enables the app to use Core Data technology.

1. A Core Data model editor is used to define entities and their attributes, and relationships among entities.
2. To execute/run the request, use the context’s fetch() method, and assign the results to a variable.
3. A predicate is an object (in Swift) that enables a developer to filter or constrain the selection, if desired.
4. A predicate has two important parts, that can be thought of as a conditional statement that you would have anywhere (as in an if statment). The first part is the predicate string, and the other is the argument(s).

1. The NSPredicate class is used to create a predicate.

1. A sort descriptor is an object (in Swift) that enables a developer to order or sequence the selection, if desired.

so a fetch request has a predicate and sort descriptor.

fetch is default for all.

use predicate and sort descriptor to get selective shit.

fetchresultcontroller is used if you need to edit data, remove data, grouped items, and if lists content is dynamic.

u got to initialize frc, set delegate, and use .performFetch()

has fetchedObjects.count

use frc.object(at: index)

let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()

// Filter the results
fetchRequest.predicate = NSPredicate(format: "age < 25", argumentArray: nil)

// Sort the results
fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]

do {
    let results = try m.ds_context.fetch(fetchRequest)
    // Handle the results
} catch let error {
    print(error.localizedDescription)
}

* CDStack
    * Core Data Stack; setup for all objects that activate core data
    * Has a save method and a factory method
    * Says “make a connection to the file system”
    * No need to edit this really!
YOU TECHNICALLY DO NOT NEED A CDSTACK SWIFT FILE but it is a template for

StoreInitliazer a swift file aka template that simply loads data into core data store

in model editor, u can see uml diagram of relationships between entities

—————————————————

if a entity contains a collection of another entity, then u access by using a as Set<Entity>

entity class collections generates functions to add remove entity

extensions to a class is GAY AF but it could be used for tableviewcontroller with a nsfetchedresultscontrollerdelegate where it automatically updates tableviewcontroller list AUTOMATICALLY

The table view data source is a fetched results controller (frc).

so it all linked!

The “Core Location” kit provides services that determine a device’s geographic location, altitude, and orientation. The framework gathers data using all available components on the device, including Wi-Fi, GPS, Bluetooth, magnetometer, barometer, and cellular hardware.

The CLLocationManager class is used. We create an instance, then configure, start getting location info, and stop when appropriate.

First, the controller that uses location services must conform to the CLLocationManagerDelegateprotocol.

Then, a number of local instance variables should be declared and initialized, and they will hold location data as it is gathered and used.
The request to get location data is usually wrapped by a function/method. It has a limited set of tasks to do:
* Configure the location manager’s settings
* Perform authorization tasks
* Begin gathering location data
A number of delegate methods must be implemented to handle events that arise during authorization and then during the gathering of location data.
* Authorization problems
* Get location failure
* Get a suitable location piece of data, then stop gathering any more location data
How you use the data is up to you. The code example does a reverse geocoding task, using an Apple service, and will attempt to report a street address for the current location. Future code examples will use maps.