pip/pitimer.h

/*
    PIP - Platform Independent Primitives
    Timer
    Copyright (C) 2013  Ivan Pelipenko peri4ko@gmail.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef PITIMER_H
#define PITIMER_H

#include <ctime>
#include <csignal>
#include "pithread.h"
#include "pistring.h"
#include "piobject.h"

typedef void (*TimerEvent)(void * , int );

class PISystemTime {
public:
	PISystemTime() {seconds = nanoseconds = 0;}
	PISystemTime(long s, long ns) {seconds = s; nanoseconds = ns; checkOverflows();}
	PISystemTime(const PISystemTime & t) {seconds = t.seconds; nanoseconds = t.nanoseconds;}
	
	double toSeconds() const {return double(seconds) + nanoseconds / 1.e+9;}
	double toMilliseconds() const {return seconds * 1.e+3 + nanoseconds / 1.e+6;}
	double toMicroseconds() const {return seconds * 1.e+6 + nanoseconds / 1.e+3;}
	double toNanoseconds() const {return seconds * 1.e+9 + double(nanoseconds);}
	void sleep() {piUSleep(piFloord(toMicroseconds()));} // wait self value, useful to wait some dT = (t1 - t0)
	PISystemTime abs() const {return PISystemTime(piAbsl(seconds), piAbsl(nanoseconds));}
	PISystemTime   operator +(const PISystemTime & t) {PISystemTime tt(*this); tt.seconds += t.seconds; tt.nanoseconds += t.nanoseconds; tt.checkOverflows(); return tt;}
	PISystemTime   operator -(const PISystemTime & t) {PISystemTime tt(*this); tt.seconds -= t.seconds; tt.nanoseconds -= t.nanoseconds; tt.checkOverflows(); return tt;}
	PISystemTime & operator +=(const PISystemTime & t) {seconds += t.seconds; nanoseconds += t.nanoseconds; checkOverflows(); return *this;}
	PISystemTime & operator -=(const PISystemTime & t) {seconds -= t.seconds; nanoseconds -= t.nanoseconds; checkOverflows(); return *this;}
	bool operator ==(const PISystemTime & t) {return ((seconds == t.seconds) && (nanoseconds == t.nanoseconds));}
	bool operator !=(const PISystemTime & t) {return ((seconds != t.seconds) || (nanoseconds != t.nanoseconds));}
	bool operator >(const PISystemTime & t) {if (seconds == t.seconds) return nanoseconds > t.nanoseconds; return seconds > t.seconds;}
	bool operator <(const PISystemTime & t) {if (seconds == t.seconds) return nanoseconds < t.nanoseconds; return seconds < t.seconds;}
	bool operator >=(const PISystemTime & t) {if (seconds == t.seconds) return nanoseconds >= t.nanoseconds; return seconds >= t.seconds;}
	bool operator <=(const PISystemTime & t) {if (seconds == t.seconds) return nanoseconds <= t.nanoseconds; return seconds <= t.seconds;}
	
	static PISystemTime fromSeconds(double v) {long s = piFloord(v); return PISystemTime(s, (v - s) * 1000000000);}
	static PISystemTime fromMilliseconds(double v) {long s = piFloord(v / 1000.); return PISystemTime(s, (v / 1000. - s) * 1000000000);}
	static PISystemTime fromMicroseconds(double v) {long s = piFloord(v / 1000000.); return PISystemTime(s, (v / 1000000. - s) * 1000000000);}
	static PISystemTime fromNanoseconds(double v) {long s = piFloord(v / 1000000000.); return PISystemTime(s, (v / 1000000000. - s) * 1000000000);}
	
	long seconds;
	long nanoseconds;
	
private:
	void checkOverflows() {while (nanoseconds >= 1000000000) {nanoseconds -= 1000000000; seconds++;} while (nanoseconds < 0) {nanoseconds += 1000000000; seconds--;}}
	
};

inline PIByteArray & operator <<(PIByteArray & s, const PISystemTime & v) {s << v.seconds << v.nanoseconds; return s;}
inline PIByteArray & operator >>(PIByteArray & s, PISystemTime & v) {s >> v.seconds >> v.nanoseconds; return s;}

struct PITime {
	int seconds;
	int minutes;
	int hours;
	PIString toString(const PIString & format = "h:mm:ss");
};

struct PIDate {
	int day;
	int month;
	int year;
	PIString toString(const PIString & format = "d.MM.yyyy");
};

struct PIDateTime {
	int seconds;
	int minutes;
	int hours;
	int day;
	int month;
	int year;
	PIString toString(const PIString & format = "h:mm:ss d.MM.yyyy");
};

/// events:
/// void timeout(void * data, int delimiter)
///
/// handlers:
/// void start(double msecs)
/// void deferredStart(double interval_msecs, double delay_msecs)
/// void deferredStart(double interval_msecs, const PIDateTime & start_datetime)
/// void stop()
/// bool waitForFinish(int timeout_msecs = -1)
/// void reset()
/// void clearDelimiters()
/// void lock()
/// void unlock()
class PITimer
#ifndef PIP_TIMER_RT
: public PIThread
#else
: public PIObject
#endif
{
public:
	PITimer(TimerEvent slot = 0, void * data = 0, bool threaded = true);
	PITimer(bool threaded);
	virtual ~PITimer();

	void setData(void * data_) {data = data_;}
	void setSlot(TimerEvent slot) {ret_func = slot;}
#ifndef PIP_TIMER_RT
#  ifdef WINDOWS
	EVENT_HANDLER0(PITimer, void, reset) {t_st = GetCurrentTime();}
	EVENT_HANDLER1(PIThread, bool, start, int, timer_delay) {start(double(timer_delay)); return true;}
	EVENT_HANDLER1(PITimer, void, start, double, msecs);
#  elif defined(MAC_OS)
	EVENT_HANDLER0(PITimer, void, reset) {clock_get_time(__pi_mac_clock, &t_st);}
	EVENT_HANDLER1(PIThread, bool, start, int, timer_delay) {start(double(timer_delay)); return true;}
	EVENT_HANDLER1(PITimer, void, start, double, msecs);
#  else
	EVENT_HANDLER0(PITimer, void, reset) {clock_gettime(0, &t_st);}
	EVENT_HANDLER1(PIThread, bool, start, int, timer_delay) {start(double(timer_delay)); return true;}
	EVENT_HANDLER1(PITimer, void, start, double, msecs);
#  endif
#else
	EVENT_HANDLER0(PITimer, void, reset) {clock_gettime(0, &t_st);}
	EVENT_HANDLER1(PITimer, void, start, double, msecs);
	EVENT_HANDLER2(PITimer, void, deferredStart, double, interval_msecs, double, delay_msecs);
	EVENT_HANDLER2(PITimer, void, deferredStart, double, interval_msecs, const PIDateTime &, start_datetime);
	EVENT_HANDLER0(PITimer, void, stop);
	EVENT_HANDLER0(PITimer, bool, waitForFinish) {return waitForFinish(-1);}
	EVENT_HANDLER1(PITimer, bool, waitForFinish, int, timeout_msecs);
	bool isRunning() const {return running;}
	void needLockRun(bool need) {lockRun = need;}
	EVENT_HANDLER0(PITimer, void, lock) {mutex_.lock();}
	EVENT_HANDLER0(PITimer, void, unlock) {mutex_.unlock();}
#endif
	void addDelimiter(int delim, TimerEvent slot = 0) {ret_funcs << TimerSlot(slot, delim);}
	void removeDelimiter(int delim) {for (int i = 0; i < ret_funcs.size_s(); ++i) if (ret_funcs[i].delim == delim) {ret_funcs.remove(i); i--;}}
	void removeDelimiter(TimerEvent slot) {for (int i = 0; i < ret_funcs.size_s(); ++i) if (ret_funcs[i].slot == slot) {ret_funcs.remove(i); i--;}}
	void removeDelimiter(int delim, TimerEvent slot) {for (int i = 0; i < ret_funcs.size_s(); ++i) if (ret_funcs[i].slot == slot && ret_funcs[i].delim == delim) {ret_funcs.remove(i); i--;}}
	EVENT_HANDLER0(PITimer, void, clearDelimiters) {ret_funcs.clear();}

	double elapsed_n(); // nanoseconds
	double elapsed_u(); // microseconds
	double elapsed_m(); // miliseconds
	double elapsed_s(); // seconds

	double reset_time_n(); // nanoseconds
	double reset_time_u(); // microseconds
	double reset_time_m(); // miliseconds
	double reset_time_s(); // seconds
	PISystemTime reset_time();

	static double elapsed_system_n(); // nanoseconds
	static double elapsed_system_u(); // microseconds
	static double elapsed_system_m(); // miliseconds
	static double elapsed_system_s(); // seconds


#ifdef PIP_TIMER_RT
	class TimerPool: public PIThread {
	public:
		TimerPool(): PIThread() {/*cout << "+++++new pool\n"; */ti = -1;}
		~TimerPool() {stop();}
		void add(PITimer * t) {mutex.lock(); timers << TimerPair(t, 0); mutex.unlock();}
		void remove(PITimer * t);
		bool isEmpty() const {return timers.isEmpty();}
		typedef PIPair<PITimer * , int> TimerPair;
	private:
		static void empty_handler(int) {}
		void begin();
		void run();
		void end() {/*cout << "pool end\n"; */if (ti != -1) timer_delete(timer); ti = -1;}
		int ti, si;
		sigset_t ss;
		sigevent se;
		sigval sv;
		itimerspec spec;

		timer_t timer;
		PIVector<TimerPair> timers;
		PIMutex mutex;
	};
	static void timer_event(sigval e);
	int ticks;
#endif
	
	EVENT2(PITimer, timeout, void * , data, int, delimiter)
	
protected:
	virtual void tick(void * data, int delimiter) {;}

private:
#ifndef PIP_TIMER_RT
	void run();
	
	PISystemTime st_time, inc_time;
#else
	bool running, threaded;
	volatile bool lockRun;
	PIMutex mutex_;
	int ti;
	itimerspec spec;
	timer_t timer;
	sigevent se;
#endif

#ifdef WINDOWS
	long
#elif defined(MAC_OS)
	mach_timespec_t
#else
	timespec
#endif
		t_st, t_cur;

	struct TimerSlot {
		TimerSlot(TimerEvent slot_ = 0, int delim_ = 1) {slot = slot_; delim = delim_; tick = 0;}
		TimerEvent slot;
		int delim;
		int tick;
	};

	void * data;
	TimerEvent ret_func;
	PIVector<TimerSlot> ret_funcs;

};

#ifdef PIP_TIMER_RT
extern PITimer::TimerPool * pool;
#endif

PITime currentTime();
PIDate currentDate();
PIDateTime currentDateTime();
PISystemTime currentSystemTime();
PIString time2string(const PITime & time, const PIString & format = "h:mm:ss"); // obsolete, use PITime.toString() instead
PIString date2string(const PIDate & date, const PIString & format = "d.MM.yyyy"); // obsolete, use PITime.toString() instead
PIString datetime2string(const PIDateTime & datetime, const PIString & format = "h:mm:ss d.MM.yyyy"); // obsolete, use PIDateTime.toString() instead

#endif // PITIMER_H