ToOne Class Reference


                    
                    
                    init(_:deleteRule:versionHashModifier:renamingIdentifier:affectedByKeyPaths:)

Initializes the metadata for the relationship. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object. Make sure to declare this relationship’s inverse relationship on its destination object. Due to Swift’s compiler limitation, only one of the relationship and its inverse can declare an inverse: argument.

class Dog: CoreStoreObject {
    let master = Relationship.ToOne<Person>("master")
}
class Person: CoreStoreObject {
    let pets = Relationship.ToManyUnordered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

public convenience init(
    _ keyPath: KeyPathString,
    deleteRule: DeleteRule = .nullify,
    versionHashModifier: @autoclosure @escaping () -> String? = nil,
    renamingIdentifier: @autoclosure @escaping () -> String? = nil,
    affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = [])

Parameters

`keyPath`	the permanent name for this relationship.
`deleteRule`	defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
`versionHashModifier`	used to mark or denote a relationship as being a different “version” than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
`renamingIdentifier`	used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property’s name.
`affectedByKeyPaths`	a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.


                    
                    
                    init(_:inverse:deleteRule:versionHashModifier:renamingIdentifier:affectedByKeyPaths:)

Initializes the metadata for the relationship. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object. Make sure to declare this relationship’s inverse relationship on its destination object. Due to Swift’s compiler limitation, only one of the relationship and its inverse can declare an inverse: argument.

class Dog: CoreStoreObject {
    let master = Relationship.ToOne<Person>("master")
}
class Person: CoreStoreObject {
    let pets = Relationship.ToManyUnordered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

public convenience init(
    _ keyPath: KeyPathString,
    inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>,
    deleteRule: DeleteRule = .nullify,
    versionHashModifier: @autoclosure @escaping () -> String? = nil,
    renamingIdentifier: @autoclosure @escaping () -> String? = nil,
    affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = [])

Parameters

`keyPath`	the permanent name for this relationship.
`inverse`	the inverse relationship that is declared for the destination object. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object.
`deleteRule`	defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
`versionHashModifier`	used to mark or denote a relationship as being a different “version” than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
`renamingIdentifier`	used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property’s name.
`affectedByKeyPaths`	a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.


                    
                    
                    init(_:inverse:deleteRule:versionHashModifier:renamingIdentifier:affectedByKeyPaths:)

Initializes the metadata for the relationship. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object. Make sure to declare this relationship’s inverse relationship on its destination object. Due to Swift’s compiler limitation, only one of the relationship and its inverse can declare an inverse: argument.

class Dog: CoreStoreObject {
    let master = Relationship.ToOne<Person>("master")
}
class Person: CoreStoreObject {
    let pets = Relationship.ToManyUnordered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

public convenience init(
    _ keyPath: KeyPathString,
    inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>,
    deleteRule: DeleteRule = .nullify,
    versionHashModifier: @autoclosure @escaping () -> String? = nil,
    renamingIdentifier: @autoclosure @escaping () -> String? = nil,
    affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = [])

Parameters

`keyPath`	the permanent name for this relationship.
`inverse`	the inverse relationship that is declared for the destination object. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object.
`deleteRule`	defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
`versionHashModifier`	used to mark or denote a relationship as being a different “version” than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
`renamingIdentifier`	used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property’s name.
`affectedByKeyPaths`	a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.


                    
                    
                    init(_:inverse:deleteRule:versionHashModifier:renamingIdentifier:affectedByKeyPaths:)

Initializes the metadata for the relationship. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object. Make sure to declare this relationship’s inverse relationship on its destination object. Due to Swift’s compiler limitation, only one of the relationship and its inverse can declare an inverse: argument.

class Dog: CoreStoreObject {
    let master = Relationship.ToOne<Person>("master")
}
class Person: CoreStoreObject {
    let pets = Relationship.ToManyUnordered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

public convenience init(
    _ keyPath: KeyPathString,
    inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>,
    deleteRule: DeleteRule = .nullify,
    versionHashModifier: @autoclosure @escaping () -> String? = nil,
    renamingIdentifier: @autoclosure @escaping () -> String? = nil,
    affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = [])

Parameters

`keyPath`	the permanent name for this relationship.
`inverse`	the inverse relationship that is declared for the destination object. All relationships require an “inverse”, so updates to to this object’s relationship are also reflected on its destination object.
`deleteRule`	defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
`versionHashModifier`	used to mark or denote a relationship as being a different “version” than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
`renamingIdentifier`	used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property’s name.
`affectedByKeyPaths`	a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.


                    
                    
                    value

The relationship value

Declaration

Swift

public var value: ReturnValueType { get set }

AnyKeyPathStringConvertible


                    
                    
                    cs_keyPathString

Declaration

Swift

public var cs_keyPathString: String { get }

KeyPathStringConvertible

ObjectType
Declaration
Swift

public typealias ObjectType = O


                    
                    
                    DestinationValueType

Declaration

Swift

public typealias DestinationValueType = D

RelationshipKeyPathStringConvertible


                    
                    
                    ReturnValueType

Declaration

Swift

public typealias ReturnValueType = DestinationValueType?

RelationshipContainer.ToOne


                    
                    
                    observe(options:changeHandler:)

Observes changes in the receiver value. When the returned CoreStoreObjectKeyValueObservation is deinited or invalidated, it will stop observing.

Declaration

Swift

public func observe(options: NSKeyValueObservingOptions = [], changeHandler: @escaping (O, CoreStoreObjectObjectDiff<D>) -> Void) -> CoreStoreObjectKeyValueObservation

Parameters


                                options

The flags indicating which values to include in the change dictionary.


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where({ $0.master == me }))

Declaration

Swift

public static func == (relationship: RelationshipContainer<O>.ToOne<D>, object: D?) -> Where<O>


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where({ $0.master != me }))

Declaration

Swift

public static func != (relationship: RelationshipContainer<O>.ToOne<D>, object: D?) -> Where<O>


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where({ [john, joe, bob] ~= $0.master }))

Declaration

Swift

public static func ~= <S>(sequence: S, relationship: RelationshipContainer<O>.ToOne<D>) -> Where<O> where D == S.Element, S : Sequence

Operations


                    
                    
                    .=(_:_:)

Assigns an object to the relationship. The operation

dog.master .= person

is equivalent to

dog.master.value = person

Declaration

Swift

public static func .= (relationship: RelationshipContainer<O>.ToOne<D>, newObject: D?)


                    
                    
                    .=(_:_:)

Assigns an object from another relationship. The operation

dog.master .= anotherDog.master

is equivalent to

dog.master.value = anotherDog.master.value

Declaration

Swift

public static func .= <O2>(relationship: RelationshipContainer<O>.ToOne<D>, relationship2: RelationshipContainer<O2>.ToOne<D>) where O2 : CoreStoreObject


                    
                    
                    .==(_:_:)

Compares equality between a relationship’s object and another object

if dog.master .== person { ... }

is equivalent to

if dog.master.value == person { ... }

Declaration

Swift

public static func .== (relationship: RelationshipContainer<O>.ToOne<D>, object: D?) -> Bool


                    
                    
                    .==(_:_:)

Compares equality between an object and a relationship’s object

if dog.master .== person { ... }

is equivalent to

if dog.master.value == person { ... }

Declaration

Swift

public static func .== (object: D?, relationship: RelationshipContainer<O>.ToOne<D>) -> Bool


                    
                    
                    .==(_:_:)

Compares equality between a relationship’s object and another relationship’s object

if dog.master .== person { ... }

is equivalent to

if dog.master.value == person { ... }

Declaration

Swift

public static func .== <O2>(relationship: RelationshipContainer<O>.ToOne<D>, relationship2: RelationshipContainer<O2>.ToOne<D>) -> Bool where O2 : CoreStoreObject