-
Notifications
You must be signed in to change notification settings - Fork 0
/
CoreData.framework.h
3470 lines (2598 loc) · 187 KB
/
CoreData.framework.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
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// ========== CoreData.framework/Headers/NSPersistentHistoryTransaction.h
/*
NSPersistentHistoryTransaction.h
Core Data
Copyright (c) 2016-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSDate.h>
NS_ASSUME_NONNULL_BEGIN
@class NSNotification;
@class NSPersistentHistoryToken;
@class NSPersistentHistoryChange;
@class NSEntityDescription;
@class NSFetchRequest;
@class NSManagedObjectConext;
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))
@interface NSPersistentHistoryTransaction : NSObject <NSCopying>
+ (nullable NSEntityDescription *)entityDescriptionWithContext:(NSManagedObjectContext *)context API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
@property (class,nullable,readonly) NSEntityDescription *entityDescription API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
@property (class,nullable,readonly) NSFetchRequest *fetchRequest API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
@property (readonly,copy) NSDate *timestamp;
@property (nullable,readonly,copy) NSArray<NSPersistentHistoryChange *>*changes;
@property (readonly) int64_t transactionNumber;
@property (readonly,copy) NSString *storeID;
@property (readonly,copy) NSString *bundleID;
@property (readonly,copy) NSString *processID;
@property (nullable,readonly,copy) NSString *contextName;
@property (nullable,readonly,copy) NSString *author;
@property (readonly,strong) NSPersistentHistoryToken *token;
// Get a notification that can be consumed by a NSManagedObjectContext
- (NSNotification *) objectIDNotification;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSFetchIndexDescription.h
/*
NSFetchIndexDescription.h
Core Data
Copyright (c) 2017-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSPredicate.h>
#import <Foundation/NSString.h>
@class NSEntityDescription;
@class NSFetchIndexElementDescription;
NS_ASSUME_NONNULL_BEGIN
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))
@interface NSFetchIndexDescription : NSObject <NSCoding> {
}
- (instancetype)initWithName:(NSString*)name elements:(nullable NSArray <NSFetchIndexElementDescription *>*)elements;
@property (copy) NSString *name;
/* Will throw if the new value is invalid (ie includes both rtree and non-rtree elements). */
@property (copy) NSArray <NSFetchIndexElementDescription *>*elements;
@property (readonly, nonatomic, nullable, assign) NSEntityDescription *entity;
/* If the index should be a partial index, specifies the predicate selecting rows for indexing */
@property (nullable, copy) NSPredicate *partialIndexPredicate;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/CoreDataDefines.h
/*
CoreDataDefines.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#ifndef _COREDATADEFINES_H
#define _COREDATADEFINES_H
#import <AvailabilityMacros.h>
#import <Availability.h>
#import <TargetConditionals.h>
//
// Platform specific defs for externs
//
//
// For MACH
//
#if defined(__MACH__)
#ifdef __cplusplus
#define COREDATA_EXTERN extern "C"
#define COREDATA_PRIVATE_EXTERN __attribute__((visibility("hidden"))) extern "C"
#else
#define COREDATA_EXTERN extern
#define COREDATA_PRIVATE_EXTERN __attribute__((visibility("hidden"))) extern
#endif
//
// For Windows
//
#elif defined(WIN32)
#ifndef _NSBUILDING_COREDATA_DLL
#define _NSWINDOWS_DLL_GOOP __declspec(dllimport)
#else
#define _NSWINDOWS_DLL_GOOP __declspec(dllexport)
#endif
#ifdef __cplusplus
#define COREDATA_EXTERN extern "C" _NSWINDOWS_DLL_GOOP
#define COREDATA_PRIVATE_EXTERN extern
#else
#define COREDATA_EXTERN _NSWINDOWS_DLL_GOOP extern
#define COREDATA_PRIVATE_EXTERN extern
#endif
//
// For Solaris
//
#elif defined(SOLARIS)
#ifdef __cplusplus
#define COREDATA_EXTERN extern "C"
#define COREDATA_PRIVATE_EXTERN extern "C"
#else
#define COREDATA_EXTERN extern
#define COREDATA_PRIVATE_EXTERN extern
#endif
#endif
//
// Framework version
//
COREDATA_EXTERN double NSCoreDataVersionNumber;
#define NSCoreDataVersionNumber10_4 46.0
#define NSCoreDataVersionNumber10_4_3 77.0
#define NSCoreDataVersionNumber10_5 185.0
#define NSCoreDataVersionNumber10_5_3 186.0
#define NSCoreDataVersionNumber10_6 246.0
#define NSCoreDataVersionNumber10_6_2 250.0
#define NSCoreDataVersionNumber10_6_3 251.0
#define NSCoreDataVersionNumber10_7 358.4
#define NSCoreDataVersionNumber10_7_2 358.12
#define NSCoreDataVersionNumber10_7_3 358.13
#define NSCoreDataVersionNumber10_7_4 358.14
#define NSCoreDataVersionNumber10_8 407.5
#define NSCoreDataVersionNumber10_8_2 407.7
#define NSCoreDataVersionNumber10_9 481.0
#define NSCoreDataVersionNumber10_9_2 481.1
#define NSCoreDataVersionNumber10_9_3 481.3
#define NSCoreDataVersionNumber10_10 526.0
#define NSCoreDataVersionNumber10_10_2 526.1
#define NSCoreDataVersionNumber10_10_3 526.2
#define NSCoreDataVersionNumber10_11 640.0
#define NSCoreDataVersionNumber10_11_3 641.3
#define NSCoreDataVersionNumber_iPhoneOS_3_0 241.0
#define NSCoreDataVersionNumber_iPhoneOS_3_1 248.0
#define NSCoreDataVersionNumber_iPhoneOS_3_2 310.2
#define NSCoreDataVersionNumber_iPhoneOS_4_0 320.5
#define NSCoreDataVersionNumber_iPhoneOS_4_1 320.11
#define NSCoreDataVersionNumber_iPhoneOS_4_2 320.15
#define NSCoreDataVersionNumber_iPhoneOS_4_3 320.17
#define NSCoreDataVersionNumber_iPhoneOS_5_0 386.1
#define NSCoreDataVersionNumber_iPhoneOS_5_1 386.5
#define NSCoreDataVersionNumber_iPhoneOS_6_0 419.0
#define NSCoreDataVersionNumber_iPhoneOS_6_1 419.1
#define NSCoreDataVersionNumber_iPhoneOS_7_0 479.1
#define NSCoreDataVersionNumber_iPhoneOS_7_1 479.3
#define NSCoreDataVersionNumber_iPhoneOS_8_0 519.0
#define NSCoreDataVersionNumber_iPhoneOS_8_3 519.15
#define NSCoreDataVersionNumber_iPhoneOS_9_0 640.0
#define NSCoreDataVersionNumber_iPhoneOS_9_2 641.4
#define NSCoreDataVersionNumber_iPhoneOS_9_3 641.6
#endif // _COREDATADEFINES_H
// ========== CoreData.framework/Headers/NSEntityMigrationPolicy.h
/*
NSEntityMigrationPolicy.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSError.h>
#import <CoreData/CoreDataDefines.h>
NS_ASSUME_NONNULL_BEGIN
/* To access the entity migration policy keys in property mapping value expressions implemented in source code use the constants as declared. To access them in custom value expression strings in the mapping model editor in Xcode follow the syntax rules outlined in the predicate format string syntax guide and refer to them as:
NSMigrationManagerKey $manager
NSMigrationSourceObjectKey $source
NSMigrationDestinationObjectKey $destination
NSMigrationEntityMappingKey $entityMapping
NSMigrationPropertyMappingKey $propertyMapping
NSMigrationEntityPolicyKey $entityPolicy
*/
COREDATA_EXTERN NSString * const NSMigrationManagerKey API_AVAILABLE(macosx(10.5),ios(3.0));
COREDATA_EXTERN NSString * const NSMigrationSourceObjectKey API_AVAILABLE(macosx(10.5),ios(3.0));
COREDATA_EXTERN NSString * const NSMigrationDestinationObjectKey API_AVAILABLE(macosx(10.5),ios(3.0));
COREDATA_EXTERN NSString * const NSMigrationEntityMappingKey API_AVAILABLE(macosx(10.5),ios(3.0));
COREDATA_EXTERN NSString * const NSMigrationPropertyMappingKey API_AVAILABLE(macosx(10.5),ios(3.0));
COREDATA_EXTERN NSString * const NSMigrationEntityPolicyKey API_AVAILABLE(macosx(10.5),ios(3.0));
@class NSManagedObject;
@class NSEntityMapping;
@class NSMigrationManager;
@class NSError;
API_AVAILABLE(macosx(10.5),ios(3.0))
@interface NSEntityMigrationPolicy : NSObject
/* Invoked by the migration manager at the start of a given entity mapping. This is also the precursor to the creation step.
*/
- (BOOL)beginEntityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Invoked by the migration manager on each source instance (as specified by the sourceExpression in the mapping) to create the corresponding destination instance. The method also associates the source and destination instances by calling NSMigrationManager's
associateSourceInstance:withDestinationInstance:forEntityMapping: method. Subclass implementations of this method must be careful to
associate the source and destination instances as required if super is not called. A return value of NO indicates an error.
*/
- (BOOL)createDestinationInstancesForSourceInstance:(NSManagedObject *)sInstance entityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Indicates the end of the creation step for the specified entity mapping, and the precursor to the next migration step. Developers can override this method to set up or clean up information for further migration steps.
*/
- (BOOL)endInstanceCreationForEntityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Constructs the relationships between the newly-created destination instances. The association lookup methods on the NSMigrationManager can be used to determine the appropriate relationship targets. A return value of NO indicates an error.
*/
- (BOOL)createRelationshipsForDestinationInstance:(NSManagedObject *)dInstance entityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Indicates the end of the relationship creation step for the specified entity mapping. This method is invoked after the createRelationshipsForDestinationInstance:entityMapping:manager:error: method, and can be used to clean up state from the creation of relationships, or prepare state for the performance of custom validation.
*/
- (BOOL)endRelationshipCreationForEntityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Invoked during the validation step of the entity migration policy, providing the option of performing custom validation on migrated objects. (Implementors must manually obtain the collection of objects they are interested in validating.)
*/
- (BOOL)performCustomValidationForEntityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
/* Invoked by the migration manager at the end of a given entity mapping. This is also the end to the validation step, which is the last step for migration.
*/
- (BOOL)endEntityMapping:(NSEntityMapping *)mapping manager:(NSMigrationManager *)manager error:(NSError **)error;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSExpressionDescription.h
/*
NSExpressionDescription.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSObject.h>
#import <CoreData/NSPropertyDescription.h>
#import <CoreData/NSAttributeDescription.h>
NS_ASSUME_NONNULL_BEGIN
@class NSExpression;
/* Special property description type intended for use with the NSFetchRequest -propertiesToFetch method.
An NSExpressionDescription describes a column to be returned from a fetch that may not appear
directly as an attribute or relationship on an entity. Examples would be: upper(attribute) or
max(attribute). NSExpressionDescriptions cannot be set as properties on NSEntityDescription. */
API_AVAILABLE(macosx(10.6),ios(3.0))
@interface NSExpressionDescription : NSPropertyDescription {
}
@property (nullable, strong) NSExpression *expression;
@property () NSAttributeType expressionResultType;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSFetchIndexElementDescription.h
/*
NSFetchIndexElementDescription.h
Core Data
Copyright (c) 2017-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSString.h>
@class NSPropertyDescription;
@class NSFetchIndexDescription;
NS_ASSUME_NONNULL_BEGIN
typedef NS_ENUM(NSUInteger, NSFetchIndexElementType) {
NSFetchIndexElementTypeBinary,
NSFetchIndexElementTypeRTree,
} API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0));
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))
@interface NSFetchIndexElementDescription : NSObject <NSCoding> {
}
- (instancetype)initWithProperty:(NSPropertyDescription*)property collationType:(NSFetchIndexElementType)collationType;
/* This may be an NSExpressionDescription that expresses a function */
@property (readonly, nullable, retain) NSPropertyDescription *property;
@property (readonly, nullable, retain) NSString *propertyName;
/* Default NSIndexTypeBinary */
@property NSFetchIndexElementType collationType;
/* Default YES. Control whether this is an ascending or descending index for indexes which support direction. */
@property (getter=isAscending) BOOL ascending;
@property (readonly, nonatomic, nullable, assign) NSFetchIndexDescription *indexDescription;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSAttributeDescription.h
/*
NSAttributeDescription.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <CoreData/NSPropertyDescription.h>
NS_ASSUME_NONNULL_BEGIN
@class NSEntityDescription;
// types explicitly distinguish between bit sizes to ensure data store independence of the underlying operating system
typedef NS_ENUM(NSUInteger, NSAttributeType) {
NSUndefinedAttributeType = 0,
NSInteger16AttributeType = 100,
NSInteger32AttributeType = 200,
NSInteger64AttributeType = 300,
NSDecimalAttributeType = 400,
NSDoubleAttributeType = 500,
NSFloatAttributeType = 600,
NSStringAttributeType = 700,
NSBooleanAttributeType = 800,
NSDateAttributeType = 900,
NSBinaryDataAttributeType = 1000,
NSUUIDAttributeType API_AVAILABLE(macosx(10.13), ios(11.0), tvos(11.0), watchos(4.0)) = 1100,
NSURIAttributeType API_AVAILABLE(macosx(10.13), ios(11.0), tvos(11.0), watchos(4.0)) = 1200,
NSTransformableAttributeType API_AVAILABLE(macosx(10.5), ios(3.0)) = 1800, // If your attribute is of NSTransformableAttributeType, the attributeValueClassName must be set or attribute value class must implement NSCopying.
NSObjectIDAttributeType API_AVAILABLE(macosx(10.6), ios(3.0)) = 2000
};
// Attributes represent individual values like strings, numbers, dates, etc.
API_AVAILABLE(macosx(10.4),ios(3.0))
@interface NSAttributeDescription : NSPropertyDescription {
}
// NSUndefinedAttributeType is valid for transient properties - Core Data will still track the property as an id value and register undo/redo actions, etc. NSUndefinedAttributeType is illegal for non-transient properties.
@property () NSAttributeType attributeType;
@property (nullable, copy) NSString *attributeValueClassName;
@property (nullable, retain) id defaultValue; // value is retained and not copied
/* Returns the version hash for the attribute. This value includes the versionHash information from the NSPropertyDescription superclass, and the attribute type.*/
@property (readonly, copy) NSData *versionHash API_AVAILABLE(macosx(10.5),ios(3.0));
/* The name of the transformer used to convert a NSTransformedAttributeType. The transformer must output NSData from transformValue and allow reverse transformation. If this value is not set, or set to nil, Core Data will default to using a transformer which uses NSCoding to archive/unarchive the attribute value.*/
@property (nullable, copy) NSString *valueTransformerName API_AVAILABLE(macosx(10.5),ios(3.0));
@property () BOOL allowsExternalBinaryDataStorage API_AVAILABLE(macosx(10.7),ios(5.0));
/* Indicates if the value of the attribute should be captured on delete when Persistent History is enabled */
@property () BOOL preservesValueInHistoryOnDeletion API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSPersistentHistoryToken.h
/*
NSPersistentHistoryToken.h
Core Data
Copyright (c) 2017-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
NS_ASSUME_NONNULL_BEGIN
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))
@interface NSPersistentHistoryToken : NSObject <NSCopying, NSSecureCoding>
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSPersistentHistoryChangeRequest.h
/*
NSPersistentHistoryChangeRequest.h
Core Data
Copyright (c) 2014-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSDate.h>
#import <CoreData/NSPersistentStoreRequest.h>
#import <CoreData/NSPersistentStoreResult.h>
NS_ASSUME_NONNULL_BEGIN
@class NSPersistentHistoryTransaction;
@class NSPersistentHistoryToken;
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))
@interface NSPersistentHistoryChangeRequest : NSPersistentStoreRequest {
}
+ (nonnull instancetype)fetchHistoryAfterDate:(NSDate *)date;
+ (nonnull instancetype)fetchHistoryAfterToken:(nullable NSPersistentHistoryToken *)token;
+ (nonnull instancetype)fetchHistoryAfterTransaction:(nullable NSPersistentHistoryTransaction *)transaction;
+ (nonnull instancetype)fetchHistoryWithFetchRequest:(NSFetchRequest *)fetchRequest API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
+ (nonnull instancetype)deleteHistoryBeforeDate:(NSDate *)date;
+ (nonnull instancetype)deleteHistoryBeforeToken:(nullable NSPersistentHistoryToken *)token;
+ (nonnull instancetype)deleteHistoryBeforeTransaction:(nullable NSPersistentHistoryTransaction *)transaction;
// The type of result that should be returned from this request. Defaults to NSPersistentHistoryResultTypeTransactionsAndChanges
@property NSPersistentHistoryResultType resultType;
@property (nullable,readonly,strong) NSPersistentHistoryToken *token;
@property (nullable,nonatomic,strong) NSFetchRequest *fetchRequest API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0));
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSPropertyDescription.h
/*
NSPropertyDescription.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSDictionary.h>
NS_ASSUME_NONNULL_BEGIN
@class NSEntityDescription;
@class NSData;
@class NSPredicate;
// Properties describe values within a managed object. There are different types of properties, each of them represented by a subclass which encapsulates the specific property behavior.
API_AVAILABLE(macosx(10.4),ios(3.0))
@interface NSPropertyDescription : NSObject <NSCoding, NSCopying> {
}
@property (nonatomic, readonly, assign) NSEntityDescription *entity;
@property (nonatomic, copy) NSString *name;
// The optional flag specifies whether a property's value can be nil or not (before an object can be persisted).
@property (getter=isOptional) BOOL optional;
// The transient flag specifies whether a property's value is persisted or ignored when an object is persisted - transient properties are still managed for undo/redo, validation, etc.
@property (getter=isTransient) BOOL transient;
// Instead of individual methods to set/get parameters like length, min and max values, formats, etc., there is a list of predicates evaluated against the managed objects and corresponding error messages (which can be localized).
@property (readonly, strong) NSArray<NSPredicate *> *validationPredicates;
@property (readonly, strong) NSArray *validationWarnings;
- (void)setValidationPredicates:(nullable NSArray<NSPredicate *> *)validationPredicates withValidationWarnings:(nullable NSArray<NSString *> *)validationWarnings;
@property (nullable, nonatomic, strong) NSDictionary *userInfo;
/* Returns a boolean value indicating if the property is important for searching. NSPersistentStores can optionally utilize this information upon store creation for operations like defining indexes.
*/
@property (getter=isIndexed) BOOL indexed API_DEPRECATED( "Use NSEntityDescription.indexes instead", macosx(10.5,10.13),ios(3.0,11.0),tvos(9.0, 11.0),watchos(2.0, 4.0));
/* Returns the version hash for the property. The version hash is used to uniquely identify a property based on its configuration. The version hash uses only values which affect the persistence of data and the user-defined versionHashModifier value. (The values which affect persistence are the name of the property, the flags for isOptional, isTransient, and isReadOnly). This value is stored as part of the version information in the metadata for stores, as well as a definition of a property involved in an NSPropertyMapping.
*/
@property (readonly, copy) NSData *versionHash API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns/sets the version hash modifier for the property. This value is included in the version hash for the property, allowing developers to mark/denote a property as being a different "version" than another, even if all of the values which affects persistence are equal. (Such a difference is important in cases where the design of a property is unchanged, but the format or content of data has changed.)
*/
@property (nullable, copy) NSString *versionHashModifier API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns a boolean value indicating if the property should be indexed by Spotlight.
*/
@property (getter=isIndexedBySpotlight) BOOL indexedBySpotlight API_AVAILABLE(macosx(10.6),ios(3.0));
/* Returns a boolean value indicating if the property data should be written out to the external record file.
*/
@property (getter=isStoredInExternalRecord) BOOL storedInExternalRecord API_DEPRECATED("Spotlight integration is deprecated. Use CoreSpotlight integration instead.", macosx(10.6,10.13),ios(3.0,11.0));
@property (nullable, copy) NSString *renamingIdentifier API_AVAILABLE(macosx(10.6),ios(3.0));
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSFetchRequest.h
/*
NSFetchRequest.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <CoreData/NSPersistentStoreRequest.h>
#import <CoreData/NSManagedObject.h>
#import <CoreData/NSManagedObjectID.h>
NS_ASSUME_NONNULL_BEGIN
@class NSEntityDescription;
@class NSManagedObjectModel;
@class NSPredicate;
@class NSPersistentStore;
@class NSSortDescriptor;
/* Definition of the possible result types a fetch request can return. */
typedef NS_OPTIONS(NSUInteger, NSFetchRequestResultType) {
NSManagedObjectResultType = 0x00,
NSManagedObjectIDResultType = 0x01,
NSDictionaryResultType API_AVAILABLE(macosx(10.6), ios(3.0)) = 0x02,
NSCountResultType API_AVAILABLE(macosx(10.6), ios(3.0)) = 0x04
};
/* Protocol conformance for possible result types a fetch request can return. */
@protocol NSFetchRequestResult <NSObject>
@end
@interface NSNumber (NSFetchedResultSupport) <NSFetchRequestResult>
@end
@interface NSDictionary (NSFetchedResultSupport) <NSFetchRequestResult>
@end
@interface NSManagedObject (NSFetchedResultSupport) <NSFetchRequestResult>
@end
@interface NSManagedObjectID (NSFetchedResultSupport) <NSFetchRequestResult>
@end
API_AVAILABLE(macosx(10.4),ios(3.0))
@interface NSFetchRequest<__covariant ResultType:id<NSFetchRequestResult>> : NSPersistentStoreRequest <NSCoding> {
}
+ (instancetype)fetchRequestWithEntityName:(NSString*)entityName API_AVAILABLE(macosx(10.7),ios(4.0));
- (instancetype)init NS_DESIGNATED_INITIALIZER;
- (instancetype)initWithEntityName:(NSString*)entityName API_AVAILABLE(macosx(10.7),ios(4.0));
// Executes the fetch request using the current managed object context. This method must be called from within a block submitted to a managed object context.
- (nullable NSArray<ResultType> *)execute:(NSError **)error API_AVAILABLE(macosx(10.12),ios(10.0),tvos(10.0),watchos(3.0));
@property (nullable, nonatomic, strong) NSEntityDescription *entity;
@property (nullable, nonatomic, readonly, strong) NSString *entityName API_AVAILABLE(macosx(10.7),ios(4.0));
@property (nullable, nonatomic, strong) NSPredicate *predicate;
@property (nullable, nonatomic, strong) NSArray<NSSortDescriptor *> *sortDescriptors;
@property (nonatomic) NSUInteger fetchLimit;
@property (nullable, nonatomic, strong) NSArray<NSPersistentStore *> *affectedStores;
/* Returns/sets the result type of the fetch request (the instance type of objects returned from executing the request.) Setting the value to NSManagedObjectIDResultType will demote any sort orderings to "best effort" hints if property values are not included in the request. Defaults to NSManagedObjectResultType.
*/
@property (nonatomic) NSFetchRequestResultType resultType API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns/sets if the fetch request includes subentities. If set to NO, the request will fetch objects of exactly the entity type of the request; if set to YES, the request will include all subentities of the entity for the request. Defaults to YES.
*/
@property (nonatomic) BOOL includesSubentities API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns/sets if, when the fetch is executed, property data is obtained from the persistent store. If the value is set to NO, the request will not obtain property information, but only information to identify each object (used to create NSManagedObjectIDs.) If managed objects for these IDs are later faulted (as a result attempting to access property values), they will incur subsequent access to the persistent store to obtain their property values. Defaults to YES.
*/
@property (nonatomic) BOOL includesPropertyValues API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns/sets if the objects resulting from a fetch request are faults. If the value is set to NO, the returned objects are pre-populated with their property values (making them fully-faulted objects, which will immediately return NO if sent the -isFault message.) If the value is set to YES, the returned objects are not pre-populated (and will receive a -didFireFault message when the properties are accessed the first time.) This setting is not utilized if the result type of the request is NSManagedObjectIDResultType, as object IDs do not have property values. Defaults to YES.
*/
@property (nonatomic) BOOL returnsObjectsAsFaults API_AVAILABLE(macosx(10.5),ios(3.0));
/* Returns/sets an array of relationship keypaths to prefetch along with the entity for the request. The array contains keypath strings in NSKeyValueCoding notation, as you would normally use with valueForKeyPath. (Prefetching allows Core Data to obtain developer-specified related objects in a single fetch (per entity), rather than incurring subsequent access to the store for each individual record as their faults are tripped.) Defaults to an empty array (no prefetching.)
*/
@property (nullable, nonatomic, copy) NSArray<NSString *> *relationshipKeyPathsForPrefetching API_AVAILABLE(macosx(10.5),ios(3.0));
/* Results accommodate the currently unsaved changes in the NSManagedObjectContext. When disabled, the fetch request skips checking unsaved changes and only returns objects that matched the predicate in the persistent store. Defaults to YES.
*/
@property (nonatomic) BOOL includesPendingChanges API_AVAILABLE(macosx(10.6),ios(3.0));
/* Returns/sets if the fetch request returns only distinct values for the fields specified by propertiesToFetch. This value is only used for NSDictionaryResultType. Defaults to NO. */
@property (nonatomic) BOOL returnsDistinctResults API_AVAILABLE(macosx(10.6),ios(3.0));
/* Specifies a collection of either NSPropertyDescriptions or NSString property names that should be fetched. The collection may represent attributes, to-one relationships, or NSExpressionDescription. If NSDictionaryResultType is set, the results of the fetch will be dictionaries containing key/value pairs where the key is the name of the specified property description. If NSManagedObjectResultType is set, then NSExpressionDescription cannot be used, and the results are managed object faults partially pre-populated with the named properties */
@property (nullable, nonatomic, copy) NSArray *propertiesToFetch API_AVAILABLE(macosx(10.6),ios(3.0));
/* Allows you to specify an offset at which rows will begin being returned. Effectively, the request will skip over 'offset' number of matching entries. For example, given a fetch which would normally return a, b, c, and d, specifying an offset of 1 will return b, c, and d and an offset of 4 will return an empty array. Offsets are ignored in nested requests such as subqueries. Default value is 0. */
@property (nonatomic) NSUInteger fetchOffset API_AVAILABLE(macosx(10.6),ios(3.0));
/* This breaks the result set into batches. The entire request will be evaluated, and the identities of all matching objects will be recorded, but no more than batchSize objects' data will be fetched from the persistent store at a time. The array returned from executing the request will be a subclass that transparently faults batches on demand. For purposes of thread safety, the returned array proxy is owned by the NSManagedObjectContext the request is executed against, and should be treated as if it were a managed object registered with that context. A batch size of 0 is treated as infinite, which disables the batch faulting behavior. The default is 0. */
@property (nonatomic) NSUInteger fetchBatchSize API_AVAILABLE(macosx(10.6),ios(3.0));
@property (nonatomic) BOOL shouldRefreshRefetchedObjects API_AVAILABLE(macosx(10.7),ios(5.0));
/* Specifies the way in which data should be grouped before a select statement is run in an SQL database.
Values passed to propertiesToGroupBy must be NSPropertyDescriptions, NSExpressionDescriptions, or keypath strings; keypaths can not contain
any to-many steps.
If GROUP BY is used, then you must set the resultsType to NSDictionaryResultsType, and the SELECT values must be literals, aggregates,
or columns specified in the GROUP BY. Aggregates will operate on the groups specified in the GROUP BY rather than the whole table. */
@property (nullable, nonatomic, copy) NSArray *propertiesToGroupBy API_AVAILABLE(macosx(10.7),ios(5.0));
/* Specifies a predicate that will be used to filter rows being returned by a query containing a GROUP BY. If a having predicate is
supplied, it will be run after the GROUP BY. Specifying a HAVING predicate requires that a GROUP BY also be specified. */
@property (nullable, nonatomic, strong) NSPredicate *havingPredicate API_AVAILABLE(macosx(10.7),ios(5.0));
@end
@class NSAsynchronousFetchResult<ResultType:id<NSFetchRequestResult>>;
typedef void (^NSPersistentStoreAsynchronousFetchResultCompletionBlock)(NSAsynchronousFetchResult *result);
API_AVAILABLE(macosx(10.10),ios(8.0))
@interface NSAsynchronousFetchRequest<ResultType:id<NSFetchRequestResult>> : NSPersistentStoreRequest {
}
@property (strong, readonly) NSFetchRequest<ResultType> * fetchRequest;
@property (nullable, strong, readonly) NSPersistentStoreAsynchronousFetchResultCompletionBlock completionBlock;
@property (nonatomic) NSInteger estimatedResultCount;
- (instancetype)initWithFetchRequest:(NSFetchRequest<ResultType> *)request completionBlock:(nullable void(^)(NSAsynchronousFetchResult<ResultType> *))blk;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSRelationshipDescription.h
/*
NSRelationshipDescription.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSObject.h>
#import <CoreData/NSPropertyDescription.h>
NS_ASSUME_NONNULL_BEGIN
@class NSEntityDescription;
typedef NS_ENUM(NSUInteger, NSDeleteRule) {
NSNoActionDeleteRule,
NSNullifyDeleteRule,
NSCascadeDeleteRule,
NSDenyDeleteRule
} ;
// Relationships represent references to other objects. They usually come in pairs, where the reference back is called the "inverse".
API_AVAILABLE(macosx(10.4),ios(3.0))
@interface NSRelationshipDescription : NSPropertyDescription {
}
@property (nullable, nonatomic, assign) NSEntityDescription *destinationEntity;
@property (nullable, nonatomic, assign) NSRelationshipDescription *inverseRelationship;
// Min and max count indicate the number of objects referenced (1/1 for a to-one relationship, 0 for the max count means undefined) - note that the counts are only enforced if the relationship value is not nil/"empty" (so as long as the relationship value is optional, there might be zero objects in the relationship, which might be less than the min count)
@property () NSUInteger maxCount;
@property () NSUInteger minCount;
@property () NSDeleteRule deleteRule;
@property (getter=isToMany, readonly) BOOL toMany; // convenience method to test whether the relationship is to-one or to-many
// Returns the version hash for the relationship. This value includes the versionHash information from the NSPropertyDescription superclass, the name of the destination entity and the inverse relationship, and the min and max count.
@property (readonly, copy) NSData *versionHash API_AVAILABLE(macosx(10.5),ios(3.0));
@property (getter=isOrdered) BOOL ordered API_AVAILABLE(macosx(10.7),ios(5.0));
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSIncrementalStore.h
/*
NSIncrementalStore.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <CoreData/NSPersistentStore.h>
#import <CoreData/NSPersistentStoreRequest.h>
NS_ASSUME_NONNULL_BEGIN
@class NSManagedObjectContext;
@class NSManagedObjectID;
@class NSManagedObject;
@class NSRelationshipDescription;
@class NSIncrementalStoreNode;
@class NSEntityDescription;
// Abstract class defining the API through which Core Data communicates with a store.
// This API is designed to allow users to create persistent stores which load and save
// data incrementally, allowing for the management of large and/or shared datasets.
API_AVAILABLE(macosx(10.7),ios(5.0))
@interface NSIncrementalStore : NSPersistentStore {
}
// CoreData expects loadMetadata: to validate that the URL used to create the store is usable
// (location exists, is writable (if applicable), schema is compatible, etc) and return an
// error if there is an issue.
// Any subclass of NSIncrementalStore which is file-based must be able to handle being initialized
// with a URL pointing to a zero-length file. This serves as an indicator that a new store is to be
// constructed at the specified location and allows applications using the store to securly create
// reservation files in known locations.
-(BOOL)loadMetadata:(NSError **)error;
// API methods that must be overriden by a subclass:
// Return a value as appropriate for the request, or nil if the request cannot be completed.
// If the request is a fetch request whose result type is set to one of NSManagedObjectResultType,
// NSManagedObjectIDResultType, NSDictionaryResultType, return an array containing all objects
// in the store matching the request.
// If the request is a fetch request whose result type is set to NSCountResultType, return an
// array containing an NSNumber of all objects in the store matching the request.
// If the request is a save request, the result should be an empty array. Note that
// save requests may have nil inserted/updated/deleted/locked collections; this should be
// treated as a request to save the store metadata.
// Note that subclasses of NSIncrementalStore should implement this method conservatively,
// and expect that unknown request types may at some point be passed to the
// method. The correct behavior in these cases would be to return nil and an error.
- (nullable id)executeRequest:(NSPersistentStoreRequest *)request withContext:(nullable NSManagedObjectContext*)context error:(NSError **)error;
// Returns an NSIncrementalStoreNode encapsulating the persistent external values for the object for an objectID.
// It should include all attributes values and may include to-one relationship values as NSManagedObjectIDs.
// Should return nil and set the error if the object cannot be found.
- (nullable NSIncrementalStoreNode *)newValuesForObjectWithID:(NSManagedObjectID*)objectID withContext:(NSManagedObjectContext*)context error:(NSError**)error;
// Returns the relationship for the given relationship on the object with ID objectID. If the relationship
// is a to-one it should return an NSManagedObjectID corresponding to the destination or NSNull if the relationship value is nil.
// If the relationship is a to-many, should return an NSSet or NSArray containing the NSManagedObjectIDs of the related objects.
// Should return nil and set the error if the source object cannot be found.
- (nullable id)newValueForRelationship:(NSRelationshipDescription*)relationship forObjectWithID:(NSManagedObjectID*)objectID withContext:(nullable NSManagedObjectContext *)context error:(NSError **)error;
// API methods that may be overriden:
+ (id)identifierForNewStoreAtURL:(NSURL*)storeURL;
// Called before executeRequest with a save request, to assign permanent IDs to newly inserted objects;
// must return the objectIDs in the same order as the objects appear in array.
- (nullable NSArray<NSManagedObjectID *> *)obtainPermanentIDsForObjects:(NSArray<NSManagedObject *> *)array error:(NSError **)error;
// Inform the store that the objects with ids in objectIDs are in use in a client NSManagedObjectContext
- (void)managedObjectContextDidRegisterObjectsWithIDs:(NSArray<NSManagedObjectID *> *)objectIDs;
// Inform the store that the objects with ids in objectIDs are no longer in use in a client NSManagedObjectContext
- (void)managedObjectContextDidUnregisterObjectsWithIDs:(NSArray<NSManagedObjectID *> *)objectIDs;
// API utility methods that should not be overriden (implemented by NSIncrementalStore):
// Returns a new objectID with retain count 1 that uses data as the key.
- (NSManagedObjectID *)newObjectIDForEntity:(NSEntityDescription *)entity referenceObject:(id)data;
// Returns the reference data used to construct the objectID. Will raise an NSInvalidArgumentException if the objectID was not created
// by this store.
- (id)referenceObjectForObjectID:(NSManagedObjectID *)objectID;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSQueryGenerationToken.h
/*
NSQueryGenerationToken.h
Core Data
Copyright (c) 2016-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
NS_ASSUME_NONNULL_BEGIN
API_AVAILABLE(macosx(10.12),ios(10.0),tvos(10.0),watchos(3.0))
// Class used to track database generations for generational querying.
// See NSManagedObjectContext for details on how it is used.
@interface NSQueryGenerationToken : NSObject <NSCopying, NSSecureCoding>
@property (class, readonly, strong) NSQueryGenerationToken *currentQueryGenerationToken; // Used to inform a context that it should use the current generation
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSPersistentCloudKitContainerOptions.h
/*
NSPersistentCloudKitContainerOptions.h
Core Data
Copyright (c) 2018-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
NS_ASSUME_NONNULL_BEGIN
/**
NSPersistentCloudKitContainerOptions provides customization of how NSPersistentCloudKitContainer aligns a given instance of NSPersistentStoreDescription with a CloudKit database.
*/
API_AVAILABLE(macosx(10.15),ios(13.0),tvos(13.0),watchos(6.0))
@interface NSPersistentCloudKitContainerOptions : NSObject
/**
shouldInitializeSchema is generally only set once during development to fully materialize a CloudKit schema for a given managed object model.
This should be set when you are ready to promote your schema to the Production CloudKit environment via the CloudKit dashboard using the following method:
1. Set shouldInitializeSchema = YES
2. Build and run your application so that it loads the CloudKit backed store (or stores)
3. Use the CloudKit Dashboard to promote the resulting schema to production
4. Set shouldInitializeSchema = NO
*/
@property(assign) BOOL shouldInitializeSchema;
/**
The container identifier of the CKContainer to use with a given instance of NSPersistentStoreDescription
*/
@property(readonly, copy) NSString *containerIdentifier;
- (instancetype)init NS_UNAVAILABLE;
- (instancetype)initWithContainerIdentifier:(NSString *)containerIdentifier NS_DESIGNATED_INITIALIZER;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSCoreDataCoreSpotlightDelegate.h
/*
NSCoreDataCoreSpotlightDelegate.h
Core Data
Copyright (c) 2017-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
@class NSManagedObjectContext;
@class NSPersistentStoreDescription;
@class NSManagedObjectModel;
@class NSManagedObject;
@class CSSearchableIndex;
@class CSSearchableItemAttributeSet;
NS_ASSUME_NONNULL_BEGIN
/* NSCoreDataSpotlightDelegate implements the CSSearchableIndexDelegate API, but can't
publicly declare it due to linkage requirements.
*/
API_AVAILABLE(macosx(10.13),ios(11.0)) API_UNAVAILABLE(tvos,watchos)
@interface NSCoreDataCoreSpotlightDelegate : NSObject {
}
/* CoreSpotlight domain identifer; default nil */
- (NSString *)domainIdentifier;
/* CoreSpotlight index name; default is the store's identifier */
- (nullable NSString *)indexName;
- (instancetype)initForStoreWithDescription:(NSPersistentStoreDescription *)description model:(NSManagedObjectModel *)model NS_DESIGNATED_INITIALIZER;
/* Create the searchable attributes for the managed object. Override to return nil if you don't
want the object in the index for some reason.
*/
- (nullable CSSearchableItemAttributeSet *)attributeSetForObject:(NSManagedObject*)object;
/* CSSearchableIndexDelegate conformance */
- (void)searchableIndex:(CSSearchableIndex *)searchableIndex reindexAllSearchableItemsWithAcknowledgementHandler:(void (^)(void))acknowledgementHandler;
- (void)searchableIndex:(CSSearchableIndex *)searchableIndex reindexSearchableItemsWithIdentifiers:(NSArray <NSString *> *)identifiers
acknowledgementHandler:(void (^)(void))acknowledgementHandler;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSAtomicStoreCacheNode.h
/*
NSAtomicStoreCacheNode.h
Core Data
Copyright (c) 2004-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSArray.h>
#import <Foundation/NSDictionary.h>
#import <Foundation/NSSet.h>
#import <Foundation/NSString.h>
#import <Foundation/NSError.h>
#import <Foundation/NSURL.h>
#import <CoreData/NSManagedObjectID.h>
#import <CoreData/NSManagedObject.h>
NS_ASSUME_NONNULL_BEGIN
@class NSEntityDescription;
API_AVAILABLE(macosx(10.5),ios(3.0))
@interface NSAtomicStoreCacheNode : NSObject {
}
/* The designated initializer for the cache node. */
- (instancetype)initWithObjectID:(NSManagedObjectID *)moid;
/* Returns the managed object ID for the cache node. */
@property (nonatomic, readonly, strong) NSManagedObjectID *objectID;
/* Returns the property cache dictionary for the cache node. This dictionary is used by -valueForKey: and -setValue:forKey: for property values. The default implementation will return nil unless the companion -setPropertyCache: method is invoked, or -setValue:forKey: is invoked on the cache node with non-nil property values.
*/
@property (nullable, nonatomic, strong) NSMutableDictionary<NSString *, id> *propertyCache;
/* Returns the value for the specified key. Subclasses must return the appropriate object value for all property keys (as specified by the names of the NSPropertyDescriptions for the entity of this cache node.) For attributes, these are instances of NSObject; for to-one relationships, the return value must be another cache node instance; for a to-many relationship, the return value must be an NSSet of the related cache nodes.
The default implementation forwards the request to the -propertyCache dictionary if the key matches a property name of the entity for the cache node. If the key does not represent a property, the standard -valueForKey: implementation will be used.
*/
- (nullable id)valueForKey:(NSString*)key;
/* Sets the value for the specified key. The default implementation forwards the request to the -propertyCache dictionary if the key matches a property name of the entity for this cache node. If the key does not represent a property, the standard -setValue:forKey: implementation will be used.
*/
- (void)setValue:(nullable id)value forKey:(NSString*)key;
@end
NS_ASSUME_NONNULL_END
// ========== CoreData.framework/Headers/NSPersistentHistoryChange.h
/*
NSPersistentHistoryChange.h
Core Data
Copyright (c) 2016-2019, Apple Inc.
All rights reserved.
*/
#import <Foundation/NSDictionary.h>
#import <Foundation/NSData.h>
#import <Foundation/NSSet.h>
NS_ASSUME_NONNULL_BEGIN
@class NSPersistentHistoryTransaction;
@class NSManagedObjectID;
@class NSPropertyDescription;
@class NSEntityDescription;
@class NSFetchRequest;
@class NSManagedObjectContext;
typedef NS_ENUM (NSInteger, NSPersistentHistoryChangeType) {
NSPersistentHistoryChangeTypeInsert,
NSPersistentHistoryChangeTypeUpdate,
NSPersistentHistoryChangeTypeDelete,
} API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0));
API_AVAILABLE(macosx(10.13),ios(11.0),tvos(11.0),watchos(4.0))