# Required

    public final class Required<V> : AttributeProtocol where V : ImportableAttributeType

The containing type for required value properties. Any type that conforms to `ImportableAttributeType` are supported.

    class Animal: CoreStoreObject {
        let species = Value.Required<String>("species", initial: "")
        let nickname = Value.Optional<String>("nickname")
        let color = Transformable.Optional<UIColor>("color")
    }

Important

`Value.Required` properties are required to be stored properties. Computed properties will be ignored, including `lazy` and `weak` properties.

- `init(_:initial:isTransient:versionHashModifier:renamingIdentifier:customGetter:customSetter:affectedByKeyPaths:)`

  Initializes the metadata for the property.

      class Person: CoreStoreObject {
          let title = Value.Required<String>("title", initial: "Mr.")
          let name = Value.Required<String>("name", initial: "")
          let displayName = Value.Required<String>(
              "displayName",
              initial: "",
              isTransient: true,
              customGetter: Person.getName(_:)
          )

          private static func getName(_ partialObject: PartialObject<Person>) -> String {
              let cachedDisplayName = partialObject.primitiveValue(for: { $0.displayName })
              if !cachedDisplayName.isEmpty {
                  return cachedDisplayName
              }
              let title = partialObject.value(for: { $0.title })
              let name = partialObject.value(for: { $0.name })
              let displayName = "\(title) \(name)"
              partialObject.setPrimitiveValue(displayName, for: { $0.displayName })
              return displayName
          }
      }

  #### Declaration

  Swift

      public init(
          _ keyPath: KeyPathString,
          initial: @autoclosure @escaping () -> V,
          isTransient: Bool = false,
          versionHashModifier: @autoclosure @escaping () -> String? = nil,
          renamingIdentifier: @autoclosure @escaping () -> String? = nil,
          customGetter: ((_ partialObject: PartialObject<O>) -> V)? = nil,
          customSetter: ((_ partialObject: PartialObject<O>, _ newValue: V) -> Void)? = nil,
          affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = [])

  #### Parameters

  `keyPath` | the permanent attribute name for this property.
  `initial` | the initial value for the property when the object is first created
  `isTransient` | `true` if the property is transient, otherwise `false`. Defaults to `false` if not specified. The transient flag specifies whether or not a property’s value is ignored when an object is saved to a persistent store. Transient properties are not saved to the persistent store, but are still managed for undo, redo, validation, and so on.
  `versionHashModifier` | used to mark or denote a property 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.
  `customGetter` | use this closure as an override for the default property getter. The closure receives a `PartialObject<O>`, which acts as a fast, type-safe KVC interface for `CoreStoreObject`. The reason a `CoreStoreObject` instance is not passed directly is because the Core Data runtime is not aware of `CoreStoreObject` properties’ static typing, and so loading those info everytime KVO invokes this accessor method incurs a cumulative performance hit (especially in KVO-heavy operations such as `ListMonitor` observing.) When accessing the property value from `PartialObject<O>`, make sure to use `PartialObject<O>.primitiveValue(for:)` instead of `PartialObject<O>.value(for:)`, which would unintentionally execute the same closure again recursively.
  `customSetter` | use this closure as an override for the default property setter. The closure receives a `PartialObject<O>`, which acts as a fast, type-safe KVC interface for `CoreStoreObject`. The reason a `CoreStoreObject` instance is not passed directly is because the Core Data runtime is not aware of `CoreStoreObject` properties’ static typing, and so loading those info everytime KVO invokes this accessor method incurs a cumulative performance hit (especially in KVO-heavy operations such as `ListMonitor` observing.) When accessing the property value from `PartialObject<O>`, make sure to use `PartialObject<O>.setPrimitiveValue(_:for:)` instead of `PartialObject<O>.setValue(_:for:)`, which would unintentionally execute the same closure again recursively.
  `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 property value.

  #### Declaration

  Swift

      public var value: V { get set }

### ValueContainer.Required

- `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, CoreStoreObjectValueDiff<V>) -> Void) -> CoreStoreObjectKeyValueObservation

  #### Parameters

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

### ValueContainer.Required

- `==(_:_:)`

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

      let person = CoreStore.fetchOne(From<Person>().where({ $0.nickname == "John" }))

  #### Declaration

  Swift

      public static func == (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `!=(_:_:)`

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

      let person = CoreStore.fetchOne(From<Person>().where({ $0.nickname != "John" }))

  #### Declaration

  Swift

      public static func != (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `<(_:_:)`

  Creates a `Where` clause by comparing if a property is less than a value

      let person = CoreStore.fetchOne(From<Person>().where({ $0.age < 20 }))

  #### Declaration

  Swift

      public static func < (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `>(_:_:)`

  Creates a `Where` clause by comparing if a property is greater than a value

      let person = CoreStore.fetchOne(From<Person>().where({ $0.age > 20 }))

  #### Declaration

  Swift

      public static func > (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `<=(_:_:)`

  Creates a `Where` clause by comparing if a property is less than or equal to a value

      let person = CoreStore.fetchOne(From<Person>().where({ $0.age <= 20 }))

  #### Declaration

  Swift

      public static func <= (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `>=(_:_:)`

  Creates a `Where` clause by comparing if a property is greater than or equal to a value

      let person = CoreStore.fetchOne(From<Person>().where({ $0.age >= 20 }))

  #### Declaration

  Swift

      public static func >= (attribute: ValueContainer<O>.Required<V>, value: V) -> Where<O>

- `~=(_:_:)`

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

      let dog = CoreStore.fetchOne(From<Dog>().where({ ["Pluto", "Snoopy", "Scooby"] ~= $0.nickname }))

  #### Declaration

  Swift

      public static func ~= <S>(sequence: S, attribute: ValueContainer<O>.Required<V>) -> Where<O> where V == S.Element, S : Sequence

### ValueContainer.Required: DynamicKeyPath

- `ObjectType`

  #### Declaration

  Swift

      public typealias ObjectType = O

- `ValueType`

  #### Declaration

  Swift

      public typealias ValueType = V

- `cs_keyPathString`

  #### Declaration

  Swift

      public var cs_keyPathString: String { get }

### Operations

- `.=(_:_:)`

  Assigns a value to the property. The operation

      animal.species .= "Swift"

  is equivalent to

      animal.species.value = "Swift"

  #### Declaration

  Swift

      public static func .= (property: ValueContainer<O>.Required<V>, newValue: V)

- `.=(_:_:)`

  Assigns a value from another property. The operation

      animal.species .= anotherAnimal.species

  is equivalent to

      animal.species.value = anotherAnimal.species.value

  #### Declaration

  Swift

      public static func .= <O2>(property: ValueContainer<O>.Required<V>, property2: ValueContainer<O2>.Required<V>) where O2 : CoreStoreObject

- `.==(_:_:)`

  Compares equality between a property’s value and another value

      if animal.species .== "Swift" { ... }

  is equivalent to

      if animal.species.value == "Swift" { ... }

  #### Declaration

  Swift

      public static func .== (property: ValueContainer<O>.Required<V>, value: V?) -> Bool

- `.==(_:_:)`

  Compares equality between a value and a property’s value

      if "Swift" .== animal.species { ... }

  is equivalent to

      if "Swift" == animal.species.value { ... }

  #### Declaration

  Swift

      public static func .== (value: V?, property: ValueContainer<O>.Required<V>) -> Bool

- `.==(_:_:)`

  Compares equality between a property’s value and another property’s value

      if animal.species .== anotherAnimal.species { ... }

  is equivalent to

      if animal.species.value == anotherAnimal.species.value { ... }

  #### Declaration

  Swift

      public static func .== (property: ValueContainer<O>.Required<V>, property2: ValueContainer<O>.Required<V>) -> Bool

- `.==(_:_:)`

  Compares equality between a property’s value and another property’s value

      if animal.species .== anotherAnimal.species { ... }

  is equivalent to

      if animal.species.value == anotherAnimal.species.value { ... }

  #### Declaration

  Swift

      public static func .== (property: ValueContainer<O>.Required<V>, property2: ValueContainer<O>.Optional<V>) -> Bool