OFObject.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of ObjFW. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE.QPL included in
 * the packaging of this file.
 *
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#import "objfw-defs.h"

#ifndef __STDC_LIMIT_MACROS
# define __STDC_LIMIT_MACROS
#endif
#ifndef __STDC_CONSTANT_MACROS
# define __STDC_CONSTANT_MACROS
#endif

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>

#import "macros.h"
#import "autorelease.h"

OF_ASSUME_NONNULL_BEGIN

typedef enum {
    OF_ORDERED_ASCENDING = -1,
    OF_ORDERED_SAME = 0,
    OF_ORDERED_DESCENDING = 1
} of_comparison_result_t;

typedef enum {
    OF_BYTE_ORDER_BIG_ENDIAN,
    OF_BYTE_ORDER_LITTLE_ENDIAN
} of_byte_order_t;

typedef struct {
    size_t location;
    size_t length;
} of_range_t;

static OF_INLINE of_range_t OF_CONST_FUNC
of_range(size_t start, size_t length)
{
    of_range_t range = { start, length };

    return range;
}

typedef double of_time_interval_t;

typedef struct {
    float x;
    float y;
} of_point_t;

static OF_INLINE of_point_t OF_CONST_FUNC
of_point(float x, float y)
{
    of_point_t point = { x, y };

    return point;
}

typedef struct {
    float width;
    float height;
} of_dimension_t;

static OF_INLINE of_dimension_t OF_CONST_FUNC
of_dimension(float width, float height)
{
    of_dimension_t dimension = { width, height };

    return dimension;
}

typedef struct {
    of_point_t origin;
    of_dimension_t size;
} of_rectangle_t;

static OF_INLINE of_rectangle_t OF_CONST_FUNC
of_rectangle(float x, float y, float width, float height)
{
    of_rectangle_t rectangle = {
        of_point(x, y),
        of_dimension(width, height)
    };

    return rectangle;
}

@class OFString;
@class OFThread;

@protocol OFObject
- (Class)class;

- (Class)superclass;

- (bool)isKindOfClass: (Class)class_;

- (bool)isMemberOfClass: (Class)class_;

- (bool)respondsToSelector: (SEL)selector;

- (bool)conformsToProtocol: (Protocol*)protocol;

- (nullable IMP)methodForSelector: (SEL)selector;

- (nullable const char*)typeEncodingForSelector: (SEL)selector;

- (nullable id)performSelector: (SEL)selector;

- (nullable id)performSelector: (SEL)selector
            withObject: (nullable id)object;

- (nullable id)performSelector: (SEL)selector
            withObject: (nullable id)object1
            withObject: (nullable id)object2;

- (bool)isEqual: (nullable id)object;

- (uint32_t)hash;

- retain;

- (unsigned int)retainCount;

- (void)release;

- autorelease;

- self;

- (bool)isProxy;
@end

OF_ROOT_CLASS
@interface OFObject <OFObject>
{
@private
    Class _isa;
}

+ (void)load;

+ (void)unload;

+ (void)initialize;

+ alloc;

+ new;

+ (Class)class;

+ (OFString*)className;

+ (bool)isSubclassOfClass: (Class)class_;

+ (Class)superclass;

+ (bool)instancesRespondToSelector: (SEL)selector;

+ (bool)conformsToProtocol: (Protocol*)protocol;

+ (nullable IMP)instanceMethodForSelector: (SEL)selector;

+ (nullable const char*)typeEncodingForInstanceSelector: (SEL)selector;

+ (OFString*)description;

+ (nullable IMP)replaceClassMethod: (SEL)selector
           withMethodFromClass: (Class)class_;

+ (nullable IMP)replaceInstanceMethod: (SEL)selector
          withMethodFromClass: (Class)class_;

+ (nullable IMP)replaceClassMethod: (SEL)selector
        withImplementation: (IMP)implementation
              typeEncoding: (const char*)typeEncoding;

+ (nullable IMP)replaceInstanceMethod: (SEL)selector
           withImplementation: (IMP)implementation
             typeEncoding: (const char*)typeEncoding;

+ (void)inheritMethodsFromClass: (Class)class_;

+ (bool)resolveClassMethod: (SEL)selector;

+ (bool)resolveInstanceMethod: (SEL)selector;

+ copy;

- init;

- (OFString*)className;

- (OFString*)description;

- (void*)allocMemoryWithSize: (size_t)size;

- (void*)allocMemoryWithSize: (size_t)size
               count: (size_t)count;

- (nullable void*)resizeMemory: (nullable void*)pointer
              size: (size_t)size;

- (nullable void*)resizeMemory: (nullable void*)pointer
              size: (size_t)size
             count: (size_t)count;

- (void)freeMemory: (nullable void*)pointer;

- (void)dealloc;

- (void)performSelector: (SEL)selector
         afterDelay: (of_time_interval_t)delay;

- (void)performSelector: (SEL)selector
         withObject: (nullable id)object
         afterDelay: (of_time_interval_t)delay;

- (void)performSelector: (SEL)selector
         withObject: (nullable id)object1
         withObject: (nullable id)object2
         afterDelay: (of_time_interval_t)delay;

#ifdef OF_HAVE_THREADS

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
      waitUntilDone: (bool)waitUntilDone;

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
         withObject: (nullable id)object
      waitUntilDone: (bool)waitUntilDone;

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
         withObject: (nullable id)object1
         withObject: (nullable id)object2
      waitUntilDone: (bool)waitUntilDone;

- (void)performSelectorOnMainThread: (SEL)selector
              waitUntilDone: (bool)waitUntilDone;

- (void)performSelectorOnMainThread: (SEL)selector
             withObject: (nullable id)object
              waitUntilDone: (bool)waitUntilDone;

- (void)performSelectorOnMainThread: (SEL)selector
             withObject: (nullable id)object1
             withObject: (nullable id)object2
              waitUntilDone: (bool)waitUntilDone;

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
         afterDelay: (of_time_interval_t)delay;

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
         withObject: (nullable id)object
         afterDelay: (of_time_interval_t)delay;

- (void)performSelector: (SEL)selector
           onThread: (OFThread*)thread
         withObject: (nullable id)object1
         withObject: (nullable id)object2
         afterDelay: (of_time_interval_t)delay;
#endif

- (nullable id)forwardingTargetForSelector: (SEL)selector;

- (void)doesNotRecognizeSelector: (SEL)selector OF_NO_RETURN;
@end

@protocol OFCopying
- copy;
@end

@protocol OFMutableCopying
- mutableCopy;
@end

@protocol OFComparing <OFObject>
- (of_comparison_result_t)compare: (id <OFComparing>)object;
@end

#ifdef __cplusplus
extern "C" {
#endif
extern id of_alloc_object(Class class_, size_t extraSize,
    size_t extraAlignment, void *OF_NULLABLE *OF_NULLABLE extra);
extern void OF_NO_RETURN_FUNC of_method_not_found(id self, SEL _cmd);
extern uint32_t of_hash_seed;
#ifdef __cplusplus
}
#endif

OF_ASSUME_NONNULL_END

#import "OFObject+Serialization.h"