ToManyUnordered Class Reference


                    
                    
                    init(_:deleteRule:minCount:maxCount: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.ToManyOrdered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

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

Parameters

`keyPath`	the permanent name for this relationship.
`minCount`	the minimum number of objects in this relationship UNLESS THE RELATIONSHIP IS EMPTY. This means there might be zero objects in the relationship, which might be less than `minCount`. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`maxCount`	the maximum number of objects in this relationship. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`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:minCount:maxCount: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.ToManyOrdered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

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

Parameters

`keyPath`	the permanent name for this relationship.
`minCount`	the minimum number of objects in this relationship UNLESS THE RELATIONSHIP IS EMPTY. This means there might be zero objects in the relationship, which might be less than `minCount`. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`maxCount`	the maximum number of objects in this relationship. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`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:minCount:maxCount: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.ToManyOrdered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

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

Parameters

`keyPath`	the permanent name for this relationship.
`minCount`	the minimum number of objects in this relationship UNLESS THE RELATIONSHIP IS EMPTY. This means there might be zero objects in the relationship, which might be less than `minCount`. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`maxCount`	the maximum number of objects in this relationship. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`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:minCount:maxCount: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.ToManyOrdered<Dog>("pets", inverse: { $0.master })
}

Declaration

Swift

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

Parameters

`keyPath`	the permanent name for this relationship.
`minCount`	the minimum number of objects in this relationship UNLESS THE RELATIONSHIP IS EMPTY. This means there might be zero objects in the relationship, which might be less than `minCount`. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`maxCount`	the maximum number of objects in this relationship. If the number of objects in the relationship do not satisfy `minCount` and `maxCount`, the transaction’s commit (or auto-commit) would fail with a validation error.
`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 = Set<DestinationValueType>

RelationshipContainer.ToManyUnordered


                    
                    
                    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, CoreStoreObjectUnorderedDiff<D>) -> Void) -> CoreStoreObjectKeyValueObservation

Parameters


                                options

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

Convenience

count
The number of elements in the set.
Declaration
Swift

public var count: Int { get }
isEmpty
A Boolean value indicating whether the range contains no elements.
Declaration
Swift

public var isEmpty: Bool { get }

Sequence


                    
                    
                    Iterator

Declaration

Swift

public typealias Iterator = AnyIterator<D>

makeIterator()
Declaration
Swift

public func makeIterator() -> Iterator

Operations


                    
                    
                    .=(_:_:)

Assigns a sequence of objects to the relationship. The operation

person.pets .= [dog, cat]

is equivalent to

person.pets.value = [dog, cat]

Declaration

Swift

public static func .= <S>(relationship: RelationshipContainer<O>.ToManyUnordered<D>, newValue: S) where D == S.Element, S : Sequence


                    
                    
                    .=(_:_:)

Assigns a sequence of objects to the relationship. The operation

person.pets .= anotherPerson.pets

is equivalent to

person.pets.value = anotherPerson.pets.value

Declaration

Swift

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


                    
                    
                    .=(_:_:)

Assigns a sequence of objects to the relationship. The operation

person.pets .= anotherPerson.pets

is equivalent to

person.pets.value = anotherPerson.pets.value

Declaration

Swift

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


                    
                    
                    .==(_:_:)

Compares the if the relationship’s objects and a set of objects have the same elements.

if person.pets .== Set<Animal>([dog, cat]) { ... }

is equivalent to

if person.pets.value == Set<Animal>([dog, cat]) { ... }

Declaration

Swift

public static func .== (relationship: RelationshipContainer<O>.ToManyUnordered<D>, set: Set<D>) -> Bool


                    
                    
                    .==(_:_:)

Compares if a set of objects and a relationship’s objects have the same elements.

if Set<Animal>([dog, cat]) .== person.pets { ... }

is equivalent to

if Set<Animal>([dog, cat]) == person.pets.value { ... }

Declaration

Swift

public static func .== (set: Set<D>, relationship: RelationshipContainer<O>.ToManyUnordered<D>) -> Bool


                    
                    
                    .==(_:_:)

Compares if a relationship’s objects and another relationship’s objects have the same elements.

if person.pets .== anotherPerson.pets { ... }

is equivalent to

if person.pets.value == anotherPerson.pets.value { ... }

Declaration

Swift

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