ObjFW  Check-in [0cfbbb367a]

- (void)run
{
	void *pool;
	OFRunLoop *runLoop;

	[OFThread _createMainThread];
	runLoop = [[[OFRunLoop alloc] init] autorelease];
	[OFRunLoop _setMainRunLoop: runLoop];
	runLoop = [OFRunLoop currentRunLoop];
	[OFRunLoop _setMainRunLoop];

	pool = objc_autoreleasePoolPush();
	[delegate applicationDidFinishLaunching];
	objc_autoreleasePoolPop(pool);

	[runLoop run];
}

/**
 * \brief Returns the run loop for the current thread.
 *
 * \return The run loop for the current thread
 */
+ (OFRunLoop*)currentRunLoop;

+ (void)_setMainRunLoop: (OFRunLoop*)mainRunLoop;
+ (void)_setMainRunLoop;
#ifdef OF_HAVE_BLOCKS
+ (void)_addAsyncReadForStream: (OFStream*)stream
			buffer: (void*)buffer
			length: (size_t)length
			 block: (of_stream_async_read_block_t)block;
+ (void)_addAsyncReadLineForStream: (OFStream*)stream
			  encoding: (of_string_encoding_t)encoding

#import "OFSortedList.h"
#import "OFTimer.h"
#import "OFDate.h"

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

static OFTLSKey *currentRunLoopKey;
static OFRunLoop *mainRunLoop;
static OFRunLoop *mainRunLoop = nil;

#ifdef OF_HAVE_BLOCKS
@interface OFRunLoop_ReadQueueItem: OFObject
{
	void *buffer;
	size_t length;
	of_stream_async_read_block_t block;

	[super dealloc];
}
@end
#endif

@implementation OFRunLoop
+ (void)initialize
{
	if (self == [OFRunLoop class])
		currentRunLoopKey = [[OFTLSKey alloc] init];
}

+ (OFRunLoop*)mainRunLoop
{
	return [[mainRunLoop retain] autorelease];
}

+ (OFRunLoop*)currentRunLoop
{
	OFThread *currentThread = [OFThread currentThread];
	OFRunLoop *runLoop = [OFThread objectForTLSKey: currentRunLoopKey];
	OFRunLoop *runLoop = [currentThread runLoop];

	if (runLoop == nil) {
	if (runLoop != nil)
		runLoop = [[OFRunLoop alloc] init];
		[OFThread setObject: runLoop
		return runLoop;
			  forTLSKey: currentRunLoopKey];
	}

	runLoop = [[[OFRunLoop alloc] init] autorelease];
	[currentThread _setRunLoop: runLoop];

	return [[runLoop retain] autorelease];
	return runLoop;
}

+ (void)_setMainRunLoop: (OFRunLoop*)mainRunLoop_
+ (void)_setMainRunLoop
{
	void *pool = objc_autoreleasePoolPush();
	mainRunLoop = [mainRunLoop_ retain];
	mainRunLoop = [[[OFThread currentThread] runLoop] retain];
	[OFThread setObject: mainRunLoop
		  forTLSKey: currentRunLoopKey];
	objc_autoreleasePoolPop(pool);
}

#ifdef OF_HAVE_BLOCKS
+ (void)_addAsyncReadForStream: (OFStream*)stream
			buffer: (void*)buffer
			length: (size_t)length
			 block: (of_stream_async_read_block_t)block

#endif

- init
{
	self = [super init];

	@try {
		void *pool = objc_autoreleasePoolPush();

		timersQueue = [[OFSortedList alloc] init];
		timersQueue = [[[OFThread currentThread] _timersQueue] retain];

		streamObserver = [[OFStreamObserver alloc] init];
		[streamObserver setDelegate: self];

		readQueues = [[OFMutableDictionary alloc] init];

		objc_autoreleasePoolPop(pool);
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

#import "OFObject.h"
#import "OFList.h"

#import "threading.h"

@class OFDate;
@class OFSortedList;
@class OFRunLoop;

#ifdef OF_HAVE_BLOCKS
typedef id (^of_thread_block_t)(id object);
#endif

/**
 * \brief A class for Thread Local Storage keys.

		OF_THREAD_RUNNING,
		OF_THREAD_WAITING_FOR_JOIN
	} running;
#ifdef OF_HAVE_BLOCKS
	of_thread_block_t block;
#endif
	id returnValue;
#ifdef OF_THREAD_M
	OFRunLoop *runLoop;
@protected
#else
@private
#endif
	OFSortedList *timersQueue;
}

#if defined(OF_HAVE_PROPERTIES) && defined(OF_HAVE_BLOCKS)
@property (copy) of_thread_block_t block;
#endif

/**

/**
 * \brief Joins a thread.
 *
 * \return The object returned by the main method of the thread.
 */
- (id)join;

/**
 * \brief Returns the run loop for the thread or nil if it has no run loop.
 *
 * \return The run loop for the thread or nil if it has no run loop
 */
- (OFRunLoop*)runLoop;
- (OFSortedList*)_timersQueue;

- (void)_setRunLoop: (OFRunLoop*)runLoop;
@end

/**
 * \brief A class for creating mutual exclusions.
 */
@interface OFMutex: OFObject
{

# include <sched.h>
#endif

#import "OFThread.h"
#import "OFList.h"
#import "OFDate.h"
#import "OFSortedList.h"
#import "OFRunLoop.h"
#import "OFAutoreleasePool.h"

#ifdef _WIN32
# include <windows.h>
#endif

#import "OFConditionBroadcastFailedException.h"

						    selector: _cmd];

	return nil;
}

- (void)handleTermination
{
	@synchronized (timersQueue) {
		/*
		 * Make sure we don't run old timers when the thread is
		 * restarted.
	[runLoop release];
		 */
		[timersQueue removeAllObjects];
	}
	runLoop = nil;
}

- (void)start
{
	if (running == OF_THREAD_RUNNING)
		@throw [OFThreadStillRunningException
		    exceptionWithClass: [self class]

				thread: self];

	running = OF_THREAD_NOT_RUNNING;

	return returnValue;
}

- (OFSortedList*)_timersQueue
- (OFRunLoop*)runLoop
{
	if (timersQueue == nil) {
	return [[runLoop retain] autorelease];
		OFSortedList *tmp = [[OFSortedList alloc] init];

}
		if (!of_atomic_cmpswap_ptr((void**)&timersQueue, nil, tmp))
			[tmp release];
	}

	return [[timersQueue retain] autorelease];

- (void)_setRunLoop: (OFRunLoop*)runLoop_
{
	OFRunLoop *old = runLoop;
	runLoop = [runLoop_ retain];
	[old release];
}

- (void)dealloc
{
	if (running == OF_THREAD_RUNNING)
		@throw [OFThreadStillRunningException
		    exceptionWithClass: [self class]
				thread: self];

	/*
	 * We should not be running anymore, but call detach in order to free
	 * the resources.
	 */
	if (running == OF_THREAD_WAITING_FOR_JOIN)
		of_thread_detach(thread);

	[object release];
	[returnValue release];
	[timersQueue release];

	[super dealloc];
}

- copy
{
	return [self retain];