# Keeps track of real time
#
# ~~~
# var clock = new Clock
#
# # sleeping at least 1s
# 1.0.sleep
# assert clock.total >= 1.0
# assert clock.lapse >= 1.0
#
# # sleeping at least 5ms
# 0.005.sleep
# assert clock.total >= 1.005
# assert clock.lapse >= 0.005
# ~~~
class Clock
	super FinalizableOnce

	# TODO use less mallocs

	# Time at creation
	private var time_at_beginning = new Timespec.monotonic_now

	# Time at last time a lapse method was called
	private var time_at_last_lapse = new Timespec.monotonic_now

	private var temp = new Timespec.monotonic_now

	# Smallest time frame reported by clock
	private fun resolution: Timespec `{
		struct timespec* tv = malloc( sizeof(struct timespec) );
#if (defined(__MACH__) || defined(TARGET_OS_IPHONE)) && !defined(CLOCK_REALTIME)
		clock_serv_t cclock;
		int nsecs;
		mach_msg_type_number_t count;
		host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
		clock_get_attributes(cclock, CLOCK_GET_TIME_RES, (clock_attr_t)&nsecs, &count);
		mach_port_deallocate(mach_task_self(), cclock);
		tv->tv_sec = 0;
		tv->tv_nsec = nsecs;
#else
		clock_getres( CLOCK_MONOTONIC, tv );
#endif
		return tv;
	`}

	# Seconds since the creation of this instance
	fun total: Float
	do
		var now = temp
		now.update
		now.minus(now, time_at_beginning)
		return now.to_f
	end

	# Seconds since the last call to `lapse`
	fun lapse: Float
	do
		var time_at_last_lapse = time_at_last_lapse
		var now = temp
		now.update
		time_at_last_lapse.minus(now, time_at_last_lapse)
		var r = time_at_last_lapse.to_f

		self.temp = time_at_last_lapse
		self.time_at_last_lapse = now

		return r
	end

	# Seconds since the last call to `lapse`, without resetting the lapse counter
	fun peek_lapse: Float
	do
		var now = temp
		now.update
		now.minus(now, time_at_last_lapse)
		return now.to_f
	end

	redef fun finalize_once
	do
		time_at_beginning.free
		time_at_last_lapse.free
		temp.free
	end
end