| 1 |
/**Interface for NSObject for GNUStep |
| 2 |
Copyright (C) 1995, 1996, 1998 Free Software Foundation, Inc. |
| 3 |
|
| 4 |
Written by: Andrew Kachites McCallum <[email protected]> |
| 5 |
Date: 1995 |
| 6 |
|
| 7 |
This file is part of the GNUstep Base Library. |
| 8 |
|
| 9 |
This library is free software; you can redistribute it and/or |
| 10 |
modify it under the terms of the GNU Lesser General Public |
| 11 |
License as published by the Free Software Foundation; either |
| 12 |
version 2 of the License, or (at your option) any later version. |
| 13 |
|
| 14 |
This library is distributed in the hope that it will be useful, |
| 15 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 17 |
Library General Public License for more details. |
| 18 |
|
| 19 |
You should have received a copy of the GNU Lesser General Public |
| 20 |
License along with this library; if not, write to the Free |
| 21 |
Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| 22 |
Boston, MA 02111 USA. |
| 23 |
|
| 24 |
AutogsdocSource: NSObject.m |
| 25 |
*/ |
| 26 |
|
| 27 |
#ifndef __NSObject_h_GNUSTEP_BASE_INCLUDE |
| 28 |
#define __NSObject_h_GNUSTEP_BASE_INCLUDE |
| 29 |
|
| 30 |
#import "NSObjCRuntime.h" |
| 31 |
#import <objc/objc.h> |
| 32 |
#import "NSZone.h" |
| 33 |
|
| 34 |
#ifdef GS_WITH_GC |
| 35 |
#undef GS_WITH_GC |
| 36 |
#endif |
| 37 |
#define GS_WITH_GC 0 |
| 38 |
|
| 39 |
#import "../GNUstepBase/GNUstep.h" |
| 40 |
|
| 41 |
#if defined(__cplusplus) |
| 42 |
extern "C" { |
| 43 |
#endif |
| 44 |
|
| 45 |
@class NSArchiver; |
| 46 |
@class NSArray; |
| 47 |
@class NSCoder; |
| 48 |
@class NSDictionary; |
| 49 |
@class NSPortCoder; |
| 50 |
@class NSMethodSignature; |
| 51 |
@class NSMutableString; |
| 52 |
@class NSRecursiveLock; |
| 53 |
@class NSString; |
| 54 |
@class NSInvocation; |
| 55 |
@class Protocol; |
| 56 |
|
| 57 |
/** |
| 58 |
* The NSObject protocol describes a minimal set of methods that all |
| 59 |
* objects are expected to support. You should be able to send any |
| 60 |
* of the messages listed in this protocol to an object, and be safe |
| 61 |
* in assuming that the receiver can handle it. |
| 62 |
*/ |
| 63 |
@protocol NSObject |
| 64 |
/** |
| 65 |
* Returns the class of the receiver. If the receiver is a proxy, then this |
| 66 |
* may return the class of the proxy target. Use -isProxy to determine whether |
| 67 |
* the receiver is a proxy. If you wish to find the real class of the |
| 68 |
* receiver, ignoring proxies, then use object_getClass(). |
| 69 |
*/ |
| 70 |
- (Class) class; |
| 71 |
/** |
| 72 |
* Returns the superclass of receiver's class. If the receiver is a proxy, |
| 73 |
* then this may return the class of the proxy target. Use -isProxy to |
| 74 |
* determine whether the receiver is a proxy. If you wish to find the real |
| 75 |
* superclass of the receiver's class, ignoring proxies, then use |
| 76 |
* class_getSuperclass(object_getClass()). |
| 77 |
*/ |
| 78 |
- (Class) superclass; |
| 79 |
/** |
| 80 |
* Returns whether the receiver is equal to the argument. Defining equality is |
| 81 |
* complex, so be careful when implementing this method. Collections such as |
| 82 |
* NSSet depend on the behaviour of this method. In particular, this method |
| 83 |
* must be commutative, so for any objects a and b: |
| 84 |
* |
| 85 |
* [a isEqual: b] == [b isEqual: a] |
| 86 |
* |
| 87 |
* This means that you must be very careful when returning YES if the argument |
| 88 |
* is of another class. For example, if you define a number class that returns |
| 89 |
* YES if the argument is a string representation of the number, then this will |
| 90 |
* break because the string will not recognise your object as being equal to |
| 91 |
* itself. |
| 92 |
* |
| 93 |
* If two objects are equal, then they must have the same hash value, however |
| 94 |
* equal hash values do not imply equality. |
| 95 |
*/ |
| 96 |
- (BOOL) isEqual: (id)anObject; |
| 97 |
/** |
| 98 |
* Returns YES if the receiver is an instance of the class, an instance of the |
| 99 |
* subclass, or (in the case of proxies), an instance of something that can be |
| 100 |
* treated as an instance of the class. |
| 101 |
*/ |
| 102 |
- (BOOL) isKindOfClass: (Class)aClass; |
| 103 |
/** |
| 104 |
* Returns YES if the receiver is an instance of the class or (in the case of |
| 105 |
* proxies), an instance of something that can be treated as an instance of the |
| 106 |
* class. |
| 107 |
* |
| 108 |
* Calling this method is rarely the correct thing to do. In most cases, a |
| 109 |
* subclass can be substituted for a superclass, so you should never need to |
| 110 |
* check that an object is really an instance of a specific class and not a |
| 111 |
* subclass. |
| 112 |
*/ |
| 113 |
- (BOOL) isMemberOfClass: (Class)aClass; |
| 114 |
/** |
| 115 |
* Returns YES if the receiver is a proxy, NO otherwise. The default |
| 116 |
* implementation of this method in NSObject returns NO, while the |
| 117 |
* implementation in NSProxy returns YES. |
| 118 |
*/ |
| 119 |
- (BOOL) isProxy; |
| 120 |
/** |
| 121 |
* Returns a hash value for the object. All objects that are equal *MUST* |
| 122 |
* return the same hash value. For efficient storage in sets, or as keys in |
| 123 |
* dictionaries, different objects should return hashes spread evenly over the |
| 124 |
* range of an integer. |
| 125 |
* |
| 126 |
* An object may not return different values from this method after being |
| 127 |
* stored in a collection. This typically means that ether the hash value must |
| 128 |
* be constant after the object's creation, or that the object may not be |
| 129 |
* modified while stored in an unordered collection. |
| 130 |
*/ |
| 131 |
- (NSUInteger) hash; |
| 132 |
/** |
| 133 |
* Returns the receiver. In a proxy, this may (but is not required to) return |
| 134 |
* the proxied object. |
| 135 |
*/ |
| 136 |
- (id) self; |
| 137 |
/** |
| 138 |
* Performs the specified selector. The selector must correspond to a method |
| 139 |
* that takes no arguments. |
| 140 |
*/ |
| 141 |
- (id) performSelector: (SEL)aSelector; |
| 142 |
/** |
| 143 |
* Performs the specified selector, with the object as the argument. This |
| 144 |
* method does not perform any automatic unboxing, so the selector must |
| 145 |
* correspond to a method that takes one object argument. |
| 146 |
*/ |
| 147 |
- (id) performSelector: (SEL)aSelector |
| 148 |
withObject: (id)anObject; |
| 149 |
/** |
| 150 |
* Performs the specified selector, with the objects as the arguments. This |
| 151 |
* method does not perform any automatic unboxing, so the selector must |
| 152 |
* correspond to a method that takes two object arguments. |
| 153 |
*/ |
| 154 |
- (id) performSelector: (SEL)aSelector |
| 155 |
withObject: (id)object1 |
| 156 |
withObject: (id)object2; |
| 157 |
/** |
| 158 |
* Returns YES if the object can respond to messages with the specified |
| 159 |
* selector. The default implementation in NSObject returns YES if the |
| 160 |
* receiver has a method corresponding to the method, but other classes may |
| 161 |
* return YES if they can respond to a selector using one of the various |
| 162 |
* forwarding mechanisms. |
| 163 |
*/ |
| 164 |
- (BOOL) respondsToSelector: (SEL)aSelector; |
| 165 |
/** |
| 166 |
* Returns YES if the receiver conforms to the specified protocol. |
| 167 |
*/ |
| 168 |
- (BOOL) conformsToProtocol: (Protocol*)aProtocol; |
| 169 |
/** |
| 170 |
* Increments the reference count of the object and returns the receiver. In |
| 171 |
* garbage collected mode, this method does nothing. In automated reference |
| 172 |
* counting mode, you may neither implement this method nor call it directly. |
| 173 |
*/ |
| 174 |
- (id) retain NS_AUTOMATED_REFCOUNT_UNAVAILABLE; |
| 175 |
/** |
| 176 |
* Decrements the reference count of the object and destroys if it there are no |
| 177 |
* remaining references. In garbage collected mode, this method does nothing. |
| 178 |
* In automated reference counting mode, you may neither implement this method |
| 179 |
* nor call it directly. |
| 180 |
*/ |
| 181 |
- (oneway void) release NS_AUTOMATED_REFCOUNT_UNAVAILABLE; |
| 182 |
/** |
| 183 |
* Performs a deferred -release operation. The object's reference count is |
| 184 |
* decremented at the end of the scope of the current autorelease pool, |
| 185 |
* identified either by a -drain message sent to the current NSAutoreleasePool |
| 186 |
* instance, or in more recent versions of Objective-C by the end of an |
| 187 |
* @autorelease_pool scope. |
| 188 |
* |
| 189 |
* In garbage collected mode, this method does nothing. In automated reference |
| 190 |
* counting mode, you may neither implement this method nor call it directly. |
| 191 |
*/ |
| 192 |
- (id) autorelease NS_AUTOMATED_REFCOUNT_UNAVAILABLE; |
| 193 |
/** |
| 194 |
* Returns the current retain count of an object. This does not include the |
| 195 |
* result of any pending autorelease operations. |
| 196 |
* |
| 197 |
* Code that relies on this method returning a sane value is broken. For |
| 198 |
* singletons, it may return NSUIntegerMax. Even when it is tracking a retain |
| 199 |
* count, it will not include on-stack pointers in manual retain/release mode, |
| 200 |
* pointers marked as __unsafe_unretain or __weak in ARC mode, or pending |
| 201 |
* autorelease operations. Its value is therefore largely meaningless. It can |
| 202 |
* occasionally be useful for debugging. |
| 203 |
*/ |
| 204 |
- (NSUInteger) retainCount NS_AUTOMATED_REFCOUNT_UNAVAILABLE; |
| 205 |
/** |
| 206 |
* Returns the description of the object. This is used by the %@ format |
| 207 |
* specifier in strings. |
| 208 |
*/ |
| 209 |
- (NSString*) description; |
| 210 |
/** |
| 211 |
* Returns the zone of the object. |
| 212 |
*/ |
| 213 |
- (NSZone*) zone NS_AUTOMATED_REFCOUNT_UNAVAILABLE; |
| 214 |
@end |
| 215 |
|
| 216 |
/** |
| 217 |
* This protocol must be adopted by any class wishing to support copying - |
| 218 |
* ie where instances of the class should be able to create new instances |
| 219 |
* which are copies of the original and, where a class has mutable and |
| 220 |
* immutable versions, where the copies are immutable. |
| 221 |
*/ |
| 222 |
@protocol NSCopying |
| 223 |
/** |
| 224 |
* Called by [NSObject-copy] passing NSDefaultMallocZone() as zone.<br /> |
| 225 |
* This method returns a copy of the receiver and, where the receiver is a |
| 226 |
* mutable variant of a class which has an immutable partner class, the |
| 227 |
* object returned is an instance of that immutable class.<br /> |
| 228 |
* The new object is <em>not</em> autoreleased, and is considered to be |
| 229 |
* 'owned' by the calling code ... which is therefore responsible for |
| 230 |
* releasing it.<br /> |
| 231 |
* In the case where the receiver is an instance of a container class, |
| 232 |
* it is undefined whether contained objects are merely retained in the |
| 233 |
* new copy, or are themselves copied, or whether some other mechanism |
| 234 |
* entirely is used. |
| 235 |
*/ |
| 236 |
- (id) copyWithZone: (NSZone*)zone; |
| 237 |
@end |
| 238 |
|
| 239 |
/** |
| 240 |
* This protocol must be adopted by any class wishing to support |
| 241 |
* mutable copying - ie where instances of the class should be able |
| 242 |
* to create mutable copies of themselves. |
| 243 |
*/ |
| 244 |
@protocol NSMutableCopying |
| 245 |
/** |
| 246 |
* Called by [NSObject-mutableCopy] passing NSDefaultMallocZone() as zone.<br /> |
| 247 |
* This method returns a copy of the receiver and, where the receiver is an |
| 248 |
* immutable variant of a class which has a mutable partner class, the |
| 249 |
* object returned is an instance of that mutable class. |
| 250 |
* The new object is <em>not</em> autoreleased, and is considered to be |
| 251 |
* 'owned' by the calling code ... which is therefore responsible for |
| 252 |
* releasing it.<br /> |
| 253 |
* In the case where the receiver is an instance of a container class, |
| 254 |
* it is undefined whether contained objects are merely retained in the |
| 255 |
* new copy, or are themselves copied, or whether some other mechanism |
| 256 |
* entirely is used. |
| 257 |
*/ |
| 258 |
- (id) mutableCopyWithZone: (NSZone*)zone; |
| 259 |
@end |
| 260 |
|
| 261 |
/** |
| 262 |
* This protocol must be adopted by any class wishing to support |
| 263 |
* saving and restoring instances to an archive, or copying them |
| 264 |
* to remote processes via the Distributed Objects mechanism. |
| 265 |
*/ |
| 266 |
@protocol NSCoding |
| 267 |
|
| 268 |
/** |
| 269 |
* Called when it is time for receiver to be serialized for writing to an |
| 270 |
* archive or network connection. Receiver should record all of its instance |
| 271 |
* variables using methods on aCoder. See documentation for [NSCoder], |
| 272 |
* [NSArchiver], [NSKeyedArchiver], and/or [NSPortCoder] for more information. |
| 273 |
*/ |
| 274 |
- (void) encodeWithCoder: (NSCoder*)aCoder; |
| 275 |
|
| 276 |
/** |
| 277 |
* Called on a freshly allocated receiver when it is time to reconstitute from |
| 278 |
* serialized bytes in an archive or from a network connection. Receiver |
| 279 |
* should load all of its instance variables using methods on aCoder. See |
| 280 |
* documentation for [NSCoder], [NSUnarchiver], [NSKeyedUnarchiver], and/or |
| 281 |
* [NSPortCoder] for more information. |
| 282 |
*/ |
| 283 |
- (id) initWithCoder: (NSCoder*)aDecoder; |
| 284 |
@end |
| 285 |
|
| 286 |
@protocol NSSecureCoding <NSCoding> |
| 287 |
+ (BOOL)supportsSecureCoding; |
| 288 |
@end |
| 289 |
|
| 290 |
|
| 291 |
GS_ROOT_CLASS @interface NSObject <NSObject> |
| 292 |
{ |
| 293 |
/** |
| 294 |
* Points to instance's class. Used by runtime to access method |
| 295 |
* implementations, etc.. Set in +alloc, Unlike other instance variables, |
| 296 |
* which are cleared there. |
| 297 |
*/ |
| 298 |
Class isa; |
| 299 |
} |
| 300 |
|
| 301 |
#if OS_API_VERSION(MAC_OS_X_VERSION_10_5, GS_API_LATEST) |
| 302 |
/** On a system which performs garbage collection, you should implement |
| 303 |
* this method to execute code when the receiver is collected.<br /> |
| 304 |
* You must not call this method yourself (except when a subclass |
| 305 |
* calls the superclass method within its own implementation). |
| 306 |
*/ |
| 307 |
- (void) finalize; |
| 308 |
#endif |
| 309 |
|
| 310 |
#if OS_API_VERSION(GS_API_MACOSX, GS_API_LATEST) |
| 311 |
- (NSString*) className; |
| 312 |
#endif |
| 313 |
|
| 314 |
+ (id) allocWithZone: (NSZone*)z; |
| 315 |
+ (id) alloc; |
| 316 |
+ (Class) class; |
| 317 |
|
| 318 |
/** |
| 319 |
* This method is automatically invoked on any class which implements it |
| 320 |
* when the class is loaded into the runtime.<br /> |
| 321 |
* It is also invoked on any category where the method is implemented |
| 322 |
* when that category is loaded into the runtime.<br /> |
| 323 |
* The +load method is called directly by the runtime and you should never |
| 324 |
* send a +load message to a class yourself.<br /> |
| 325 |
* This method is called <em>before</em> the +initialize message is sent |
| 326 |
* to the class, so you cannot depend on class initialisation having been |
| 327 |
* performed, or upon other classes existing (apart from superclasses of |
| 328 |
* the receiver, since +load is called on superclasses before it is called |
| 329 |
* on their subclasses).<br /> |
| 330 |
* As a gross generalisation, it is safe to use C code, including |
| 331 |
* most ObjectiveC runtime functions within +load, but attempting to send |
| 332 |
* messages to ObjectiveC objects is likely to fail.<br /> |
| 333 |
* In GNUstep, this method is implemented for NSObject to perform some |
| 334 |
* initialisation for the base library.<br /> |
| 335 |
* If you implement +load for a class, don't call [super load] in your |
| 336 |
* implementation. |
| 337 |
*/ |
| 338 |
+ (void) load; |
| 339 |
|
| 340 |
/** |
| 341 |
* This message is automatically sent to a class by the runtime. It is |
| 342 |
* sent once for each class, just before the class is used for the first |
| 343 |
* time (excluding any automatic call to +load by the runtime).<br /> |
| 344 |
* The message is sent in a thread-safe manner ... other threads may not |
| 345 |
* call methods of the class until +initialize has finished executing.<br /> |
| 346 |
* If the class has a superclass, its implementation of +initialize is |
| 347 |
* called first.<br /> |
| 348 |
* If the class does not implement +initialize then the implementation |
| 349 |
* in the closest superclass may be called. This means that +initialize may |
| 350 |
* be called more than once, and the recommended way to handle this by |
| 351 |
* using the |
| 352 |
* <code> |
| 353 |
* if (self == [classname class]) |
| 354 |
* </code> |
| 355 |
* conditional to check whether the method is being called for a subclass.<br /> |
| 356 |
* You should never call +initialize yourself ... let the runtime do it.<br /> |
| 357 |
* You can implement +initialize in your own class if you need to. |
| 358 |
* NSObject's implementation handles essential root object and base |
| 359 |
* library initialization.<br /> |
| 360 |
* It should be safe to call [super initialize] in your implementation |
| 361 |
* of +initialize. |
| 362 |
*/ |
| 363 |
+ (void) initialize; |
| 364 |
+ (IMP) instanceMethodForSelector: (SEL)aSelector; |
| 365 |
+ (NSMethodSignature*) instanceMethodSignatureForSelector: (SEL)aSelector; |
| 366 |
+ (BOOL) instancesRespondToSelector: (SEL)aSelector; |
| 367 |
+ (BOOL) isSubclassOfClass: (Class)aClass; |
| 368 |
+ (id) new; |
| 369 |
+ (void) poseAsClass: (Class)aClassObject; |
| 370 |
+ (id) setVersion: (NSInteger)aVersion; |
| 371 |
+ (NSInteger) version; |
| 372 |
|
| 373 |
- (id) awakeAfterUsingCoder: (NSCoder*)aDecoder; |
| 374 |
- (Class) classForArchiver; |
| 375 |
- (Class) classForCoder; |
| 376 |
- (id) copy; |
| 377 |
- (void) dealloc; |
| 378 |
- (void) doesNotRecognizeSelector: (SEL)aSelector; |
| 379 |
- (void) forwardInvocation: (NSInvocation*)anInvocation; |
| 380 |
- (id) init; |
| 381 |
- (IMP) methodForSelector: (SEL)aSelector; |
| 382 |
- (NSMethodSignature*) methodSignatureForSelector: (SEL)aSelector; |
| 383 |
- (id) mutableCopy; |
| 384 |
- (id) replacementObjectForArchiver: (NSArchiver*)anArchiver; |
| 385 |
- (id) replacementObjectForCoder: (NSCoder*)anEncoder; |
| 386 |
- (Class) superclass; |
| 387 |
#if OS_API_VERSION(MAC_OS_X_VERSION_10_5, GS_API_LATEST) |
| 388 |
/** |
| 389 |
* This method will be called when attempting to send a message a class that |
| 390 |
* does not understand it. The class may install a new method for the given |
| 391 |
* selector and return YES, otherwise it should return NO. |
| 392 |
* |
| 393 |
* Note: This method is only reliable when using the GNUstep runtime. If you |
| 394 |
* require compatibility with the GCC runtime, you must also implement |
| 395 |
* -forwardInvocation: with equivalent semantics. This will be considerably |
| 396 |
* slower, but more portable. |
| 397 |
*/ |
| 398 |
+ (BOOL) resolveClassMethod: (SEL)name; |
| 399 |
|
| 400 |
/** |
| 401 |
* This method will be called when attempting to send a message an instance |
| 402 |
* that does not understand it. The class may install a new method for the |
| 403 |
* given selector and return YES, otherwise it should return NO. |
| 404 |
* |
| 405 |
* Note: This method is only reliable when using the GNUstep runtime. If you |
| 406 |
* require compatibility with the GCC runtime, you must also implement |
| 407 |
* -forwardInvocation: with equivalent semantics. This will be considerably |
| 408 |
* slower, but more portable. |
| 409 |
*/ |
| 410 |
+ (BOOL) resolveInstanceMethod: (SEL)name; |
| 411 |
#endif |
| 412 |
#if OS_API_VERSION(MAC_OS_X_VERSION_10_6, GS_API_LATEST) |
| 413 |
/** |
| 414 |
* Returns an auto-accessing proxy for the given object. This proxy sends a |
| 415 |
* -beginContentAccess message to the receiver when it is created and an |
| 416 |
* -endContentAccess message when it is destroyed. This prevents an object |
| 417 |
* that implements the NSDiscardableContent protocol from having its contents |
| 418 |
* discarded for as long as the proxy exists. |
| 419 |
* |
| 420 |
* On systems using the GNUstep runtime, messages send to the proxy will be |
| 421 |
* slightly slower than direct messages. With the GCC runtime, they will be |
| 422 |
* approximately two orders of magnitude slower. The GNUstep runtime, |
| 423 |
* therefore, is strongly recommended for code calling this method. |
| 424 |
*/ |
| 425 |
- (id) autoContentAccessingProxy; |
| 426 |
|
| 427 |
/** |
| 428 |
* If an object does not understand a message, it may delegate it to another |
| 429 |
* object. Returning nil indicates that forwarding should not take place. The |
| 430 |
* default implementation of this returns nil, but care should be taken when |
| 431 |
* subclassing NSObject subclasses and overriding this method that |
| 432 |
* the superclass implementation is called if returning nil. |
| 433 |
* |
| 434 |
* Note: This method is only reliable when using the GNUstep runtime and code |
| 435 |
* compiled with clang. If you require compatibility with GCC and the GCC |
| 436 |
* runtime, you must also implement -forwardInvocation: with equivalent |
| 437 |
* semantics. This will be considerably slower, but more portable. |
| 438 |
*/ |
| 439 |
- (id) forwardingTargetForSelector: (SEL)aSelector; |
| 440 |
|
| 441 |
#endif |
| 442 |
@end |
| 443 |
|
| 444 |
/** |
| 445 |
* Used to allocate memory to hold an object, and initialise the |
| 446 |
* class of the object to be aClass etc. The allocated memory will |
| 447 |
* be extraBytes larger than the space actually needed to hold the |
| 448 |
* instance variables of the object.<br /> |
| 449 |
* This function is used by the [NSObject+allocWithZone:] method. |
| 450 |
*/ |
| 451 |
GS_EXPORT id |
| 452 |
NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone); |
| 453 |
|
| 454 |
/** |
| 455 |
* Used to release the memory used by an object.<br /> |
| 456 |
* This function is used by the [NSObject-dealloc] method. |
| 457 |
*/ |
| 458 |
GS_EXPORT void |
| 459 |
NSDeallocateObject(id anObject); |
| 460 |
|
| 461 |
/** |
| 462 |
* Used to copy anObject. This makes a bitwise copy of anObject to |
| 463 |
* memory allocated from zone. The allocated memory will be extraBytes |
| 464 |
* longer than that necessary to actually store the instance variables |
| 465 |
* of the copied object.<br /> |
| 466 |
*/ |
| 467 |
GS_EXPORT NSObject * |
| 468 |
NSCopyObject(NSObject *anObject, NSUInteger extraBytes, NSZone *zone); |
| 469 |
|
| 470 |
/** |
| 471 |
* Returns a flag to indicate whether anObject should be retained or |
| 472 |
* copied in order to make a copy in the specified zone.<br /> |
| 473 |
* Basically, this tests to see if anObject was allocated from |
| 474 |
* requestedZone and returns YES if it was. |
| 475 |
*/ |
| 476 |
GS_EXPORT BOOL |
| 477 |
NSShouldRetainWithZone(NSObject *anObject, NSZone *requestedZone); |
| 478 |
|
| 479 |
GS_EXPORT BOOL |
| 480 |
NSDecrementExtraRefCountWasZero(id anObject); |
| 481 |
|
| 482 |
GS_EXPORT NSUInteger |
| 483 |
NSExtraRefCount(id anObject); |
| 484 |
|
| 485 |
GS_EXPORT void |
| 486 |
NSIncrementExtraRefCount(id anObject); |
| 487 |
|
| 488 |
#if OS_API_VERSION(GS_API_NONE, GS_API_NONE) |
| 489 |
|
| 490 |
/** Global lock to be used by classes when operating on any global |
| 491 |
data that invoke other methods which also access global; thus, |
| 492 |
creating the potential for deadlock. */ |
| 493 |
GS_EXPORT NSRecursiveLock *gnustep_global_lock; |
| 494 |
|
| 495 |
@interface NSObject (NEXTSTEP) |
| 496 |
- (id) error:(const char *)aString, ...; |
| 497 |
/* - (const char *) name; |
| 498 |
Removed because OpenStep has -(NSString*)name; */ |
| 499 |
@end |
| 500 |
|
| 501 |
#if GS_API_VERSION(GS_API_NONE, 011700) |
| 502 |
@interface NSObject (GNUstep) |
| 503 |
+ (void) enableDoubleReleaseCheck: (BOOL)enable; |
| 504 |
@end |
| 505 |
#endif |
| 506 |
|
| 507 |
#endif |
| 508 |
|
| 509 |
#import "NSDate.h" |
| 510 |
/** |
| 511 |
* Declares some methods for sending messages to self after a fixed delay. |
| 512 |
* (These methods <em>are</em> in OpenStep and OS X.) |
| 513 |
*/ |
| 514 |
@interface NSObject (TimedPerformers) |
| 515 |
|
| 516 |
/** |
| 517 |
* Cancels any perform operations set up for the specified target |
| 518 |
* in the current run loop. |
| 519 |
*/ |
| 520 |
+ (void) cancelPreviousPerformRequestsWithTarget: (id)obj; |
| 521 |
|
| 522 |
/** |
| 523 |
* Cancels any perform operations set up for the specified target |
| 524 |
* in the current loop, but only if the value of aSelector and argument |
| 525 |
* with which the performs were set up match those supplied.<br /> |
| 526 |
* Matching of the argument may be either by pointer equality or by |
| 527 |
* use of the [NSObject-isEqual:] method. |
| 528 |
*/ |
| 529 |
+ (void) cancelPreviousPerformRequestsWithTarget: (id)obj |
| 530 |
selector: (SEL)s |
| 531 |
object: (id)arg; |
| 532 |
/** |
| 533 |
* Sets given message to be sent to this instance after given delay, |
| 534 |
* in any run loop mode. See [NSRunLoop]. |
| 535 |
*/ |
| 536 |
- (void) performSelector: (SEL)s |
| 537 |
withObject: (id)arg |
| 538 |
afterDelay: (NSTimeInterval)seconds; |
| 539 |
|
| 540 |
/** |
| 541 |
* Sets given message to be sent to this instance after given delay, |
| 542 |
* in given run loop modes. See [NSRunLoop]. |
| 543 |
*/ |
| 544 |
- (void) performSelector: (SEL)s |
| 545 |
withObject: (id)arg |
| 546 |
afterDelay: (NSTimeInterval)seconds |
| 547 |
inModes: (NSArray*)modes; |
| 548 |
@end |
| 549 |
|
| 550 |
#if OS_API_VERSION(MAC_OS_X_VERSION_10_6, GS_API_LATEST) |
| 551 |
/** |
| 552 |
* The NSDiscardableContent protocol is used by objects which encapsulate data |
| 553 |
* which may be discarded if resource constraints are exceeded. These |
| 554 |
* constraints are typically, but not always, related memory. |
| 555 |
*/ |
| 556 |
@protocol NSDiscardableContent |
| 557 |
|
| 558 |
/** |
| 559 |
* This method is called before any access to the object. It returns YES if |
| 560 |
* the object's content is still valid. The caller must call -endContentAccess |
| 561 |
* once for every call to -beginContentAccess; |
| 562 |
*/ |
| 563 |
- (BOOL) beginContentAccess; |
| 564 |
|
| 565 |
/** |
| 566 |
* Discards the contents of the object if it is not currently being edited. |
| 567 |
*/ |
| 568 |
- (void) discardContentIfPossible; |
| 569 |
|
| 570 |
/** |
| 571 |
* This method indicates that the caller has finished accessing the contents of |
| 572 |
* the object adopting this protocol. Every call to -beginContentAccess must |
| 573 |
* be be paired with a call to this method after the caller has finished |
| 574 |
* accessing the contents. |
| 575 |
*/ |
| 576 |
- (void) endContentAccess; |
| 577 |
|
| 578 |
/** |
| 579 |
* Returns YES if the contents of the object have been discarded, either via a |
| 580 |
* call to -discardContentIfPossible while the object is not in use, or by some |
| 581 |
* implementation dependent mechanism. |
| 582 |
*/ |
| 583 |
- (BOOL) isContentDiscarded; |
| 584 |
@end |
| 585 |
#endif |
| 586 |
#if defined(__cplusplus) |
| 587 |
} |
| 588 |
#endif |
| 589 |
|
| 590 |
#if !NO_GNUSTEP && !defined(GNUSTEP_BASE_INTERNAL) |
| 591 |
#import "../GNUstepBase/NSObject+GNUstepBase.h" |
| 592 |
#endif |
| 593 |
|
| 594 |
#endif /* __NSObject_h_GNUSTEP_BASE_INCLUDE */ |