Major plugin refactor and cleanup.

Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.

vendor/POCO/Foundation/include/Poco/Timer.h

@@ -0,0 +1,229 @@
+//
+// Timer.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Timer
+//
+// Definition of the Timer and related classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Timer_INCLUDED
+#define Foundation_Timer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include "Poco/Thread.h"
+#include "Poco/Clock.h"
+
+
+namespace Poco {
+
+
+class AbstractTimerCallback;
+class ThreadPool;
+
+
+class Foundation_API Timer: protected Runnable
+	/// This class implements a thread-based timer.
+	/// A timer starts a thread that first waits for a given start interval.
+	/// Once that interval expires, the timer callback is called repeatedly
+	/// in the given periodic interval. If the interval is 0, the timer is only
+	/// called once.
+	/// The timer callback method can stop the timer by setting the 
+	/// timer's periodic interval to 0.
+	///
+	/// The timer callback runs in its own thread, so multithreading
+	/// issues (proper synchronization) have to be considered when writing 
+	/// the callback method.
+	///
+	/// The exact interval at which the callback is called depends on many 
+	/// factors like operating system, CPU performance and system load and
+	/// may differ from the specified interval.
+	///
+	/// The time needed to execute the timer callback is not included
+	/// in the interval between invocations. For example, if the interval
+	/// is 500 milliseconds, and the callback needs 400 milliseconds to
+	/// execute, the callback function is nevertheless called every 500
+	/// milliseconds. If the callback takes longer to execute than the
+	/// interval, the callback function will not be called until the next
+	/// proper interval. The number of skipped invocations since the last
+	/// invocation will be recorded and can be obtained by the callback
+	/// by calling skipped().
+	///
+	/// The timer thread is taken from a thread pool, so
+	/// there is a limit to the number of available concurrent timers.
+{
+public:
+	Timer(long startInterval = 0, long periodicInterval = 0);
+		/// Creates a new timer object. StartInterval and periodicInterval
+		/// are given in milliseconds. If a periodicInterval of zero is 
+		/// specified, the callback will only be called once, after the
+		/// startInterval expires.
+		/// To start the timer, call the Start() method.
+
+	virtual ~Timer();
+		/// Stops and destroys the timer.
+
+	void start(const AbstractTimerCallback& method);
+		/// Starts the timer.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		///
+		/// The timer thread is taken from the global default thread pool.
+
+	void start(const AbstractTimerCallback& method, Thread::Priority priority);
+		/// Starts the timer in a thread with the given priority.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		///
+		/// The timer thread is taken from the global default thread pool.
+
+	void start(const AbstractTimerCallback& method, ThreadPool& threadPool);
+		/// Starts the timer.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+
+	void start(const AbstractTimerCallback& method, Thread::Priority priority, ThreadPool& threadPool);
+		/// Starts the timer in a thread with the given priority.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		
+	void stop();
+		/// Stops the timer. If the callback method is currently running
+		/// it will be allowed to finish first.
+		/// WARNING: Never call this method from within the callback method,
+		/// as a deadlock would result. To stop the timer from within the
+		/// callback method, call restart(0).
+
+	void restart();
+		/// Restarts the periodic interval. If the callback method is already running,
+		/// nothing will happen.
+
+	void restart(long milliseconds);
+		/// Sets a new periodic interval and restarts the timer.
+		/// An interval of 0 will stop the timer.
+
+	long getStartInterval() const;
+		/// Returns the start interval.
+
+	void setStartInterval(long milliseconds);
+		/// Sets the start interval. Will only be 
+		/// effective before start() is called.
+
+	long getPeriodicInterval() const;
+		/// Returns the periodic interval.
+
+	void setPeriodicInterval(long milliseconds);
+		/// Sets the periodic interval. If the timer is already running
+		/// the new interval will be effective when the current interval
+		/// expires.
+		
+	long skipped() const;
+		/// Returns the number of skipped invocations since the last invocation.
+		/// Skipped invocations happen if the timer callback function takes
+		/// longer to execute than the timer interval.
+
+protected:
+	void run();
+
+private:
+	long _startInterval;
+	long _periodicInterval;
+	Event         _wakeUp;
+	Event         _done;
+	long          _skipped;
+	AbstractTimerCallback* _pCallback;
+	Clock                  _nextInvocation;
+	mutable FastMutex      _mutex;
+	
+	Timer(const Timer&);
+	Timer& operator = (const Timer&);
+};
+
+
+class Foundation_API AbstractTimerCallback
+	/// This is the base class for all instantiations of
+	/// the TimerCallback template.
+{
+public:
+	AbstractTimerCallback();
+	AbstractTimerCallback(const AbstractTimerCallback& callback);
+	virtual ~AbstractTimerCallback();
+	
+	AbstractTimerCallback& operator = (const AbstractTimerCallback& callback);
+
+	virtual void invoke(Timer& timer) const = 0;
+	virtual AbstractTimerCallback* clone() const = 0;
+};
+
+
+template <class C> 
+class TimerCallback: public AbstractTimerCallback
+	/// This template class implements an adapter that sits between
+	/// a Timer and an object's method invoked by the timer.
+	/// It is quite similar in concept to the RunnableAdapter, but provides 
+	/// some Timer specific additional methods.
+	/// See the Timer class for information on how
+	/// to use this template class.
+{
+public:
+	typedef void (C::*Callback)(Timer&);
+
+	TimerCallback(C& object, Callback method): _pObject(&object), _method(method)
+	{
+	}
+
+	TimerCallback(const TimerCallback& callback): _pObject(callback._pObject), _method(callback._method)
+	{
+	}
+
+	~TimerCallback()
+	{
+	}
+
+	TimerCallback& operator = (const TimerCallback& callback)
+	{
+		if (&callback != this)
+		{
+			_pObject = callback._pObject;
+			_method  = callback._method;
+		}
+		return *this;
+	}
+
+	void invoke(Timer& timer) const
+	{
+		(_pObject->*_method)(timer);
+	}
+
+	AbstractTimerCallback* clone() const
+	{
+		return new TimerCallback(*this);
+	}
+
+private:
+	TimerCallback();
+
+	C*       _pObject;
+	Callback _method;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Timer_INCLUDED