ObjFW  Check-in [4572170728]

/*!
 * @brief Adds an OFTimer to the run loop.
 *
 * @param timer The timer to add
 */
- (void)addTimer: (OFTimer*)timer;

- (void)OF_removeTimer: (OFTimer*)timer;

/*!
 * @brief Starts the run loop.
 */
- (void)run;
@end

	[timersQueueLock lock];
	@try {
		[timersQueue insertObject: timer];
	} @finally {
		[timersQueueLock unlock];
	}

	[timer OF_setInRunLoop: self];

	[streamObserver cancel];
}

- (void)OF_removeTimer: (OFTimer*)timer
{
	[timersQueueLock lock];
	@try {
		of_list_object_t *iter;

		for (iter = [timersQueue firstListObject]; iter != NULL;
		    iter = iter->next) {
			if ([iter->object isEqual: timer]) {
				[timersQueue removeListObject: iter];
				break;
			}
		}
	} @finally {
		[timersQueueLock unlock];
	}
}

- (void)streamIsReadyForReading: (OFStream*)stream
{
	OFList *queue = [readQueues objectForKey: stream];
	of_list_object_t *listObject;

	OF_ENSURE(queue != nil);

			if (listObject != NULL &&
			    [[listObject->object fireDate] compare: now] !=
			    OF_ORDERED_DESCENDING) {
				timer =
				    [[listObject->object retain] autorelease];

				[timersQueue removeListObject: listObject];

				[timer OF_setInRunLoop: nil];
			} else
				timer = nil;
		} @finally {
			[timersQueueLock unlock];
		}

		if ([timer isValid])

 */

#import "OFObject.h"

@class OFTimer;
@class OFDate;
@class OFCondition;
@class OFRunLoop;

#ifdef OF_HAVE_BLOCKS
typedef void (^of_timer_block_t)(OFTimer*);
#endif

/*!
 * @brief A class for creating and firing timers.

	uint8_t arguments;
	BOOL repeats;
#ifdef OF_HAVE_BLOCKS
	of_timer_block_t block;
#endif
	BOOL isValid, done;
	OFCondition *condition;
	OFRunLoop *inRunLoop;
}

#ifdef OF_HAVE_PROPERTIES
@property (retain) OFDate *fireDate;
#endif

/*!
 * @brief Creates and schedules a new timer with the specified time interval.
 *
 * @param interval The time interval after which the timer should be executed
 *		   when fired

/*!
 * @brief Returns the next date at which the timer will fire.
 *
 * @return The next date at which the timer will fire
 */
- (OFDate*)fireDate;

/*!
 * @brief Sets the next date at which the timer will fire.
 *
 * If the timer is already scheduled in a run loop, it will be rescheduled.
 * Note that rescheduling is an expensive operation, though it still might be
 * preferrable to reschedule instead of invalidating the timer and creating a
 * new one.
 *
 * @param fireDate The next date at which the timer will fire
 */
- (void)setFireDate: (OFDate*)fireDate;

/*!
 * @brief Invalidates the timer, preventing it from firing.
 */
- (void)invalidate;

/*!
 * @brief Returns whether the timer is valid.

 */
- (double)timeInterval;

/*!
 * @brief Waits until the timer fired.
 */
- (void)waitUntilDone;

- (void)OF_setInRunLoop: (OFRunLoop*)inRunLoop;
@end

 * 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.
 */

#include "config.h"

#include <assert.h>

#import "OFTimer.h"
#import "OFDate.h"
#import "OFRunLoop.h"
#import "OFCondition.h"

#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"

	return self;
}
#endif

- (void)dealloc
{
	/*
	 * The run loop references the timer, so it should never be deallocated
	 * if it is still in a run loop.
	 */
	assert(inRunLoop == nil);

	[fireDate release];
	[target release];
	[object1 release];
	[object2 release];
#ifdef OF_HAVE_BLOCKS
	[block release];
#endif

		isValid = NO;
}

- (OFDate*)fireDate
{
	OF_GETTER(fireDate, YES)
}

- (void)setFireDate: (OFDate*)fireDate_
{
	[self retain];
	@try {
		@synchronized (self) {
			[inRunLoop OF_removeTimer: self];

			OF_SETTER(fireDate, fireDate_, YES, 0)

			[inRunLoop addTimer: self];
		}
	} @finally {
		[self release];
	}
}

- (double)timeInterval
{
	return interval;
}

- (void)invalidate

		}

		[condition wait];
	} @finally {
		[condition unlock];
	}
}

- (void)OF_setInRunLoop: (OFRunLoop*)inRunLoop_
{
	OF_SETTER(inRunLoop, inRunLoop_, YES, 0)
}
@end