1 files changed, 215 insertions, 0 deletions
diff --git a/include/nmeaparse/Event.h b/include/nmeaparse/Event.h
new file mode 100644
index 0000000..4343496
--- /dev/null
+++ b/include/nmeaparse/Event.h
@@ -0,0 +1,215 @@
+/*
+ * Event.h
+ *
+ *  Created on: Sep 5, 2014
+ *      Author: Cameron Karlsson
+ */
+
+#ifndef EVENT_H_
+#define EVENT_H_
+
+#include <list>
+#include <functional>
+#include <cstdint>
+
+
+
+namespace nmea {
+
+
+	template<class> class EventHandler;
+	template<class> class Event;
+
+
+	template<typename... Args>
+	class EventHandler<void(Args...)>
+	{
+		friend Event<void(Args...)>;
+	private:
+		// Typenames
+		typename Event<void(Args...)>::ListIterator _iterator;
+
+		// Static members
+		static uint64_t LastID;
+
+		// Properties
+		uint64_t ID;
+		std::function<void(Args...)> handler;
+
+		// Functions
+		void _copy(const EventHandler& ref){
+			if (&ref != this){
+				_iterator = ref._iterator;
+				handler = ref.handler;
+				ID = ref.ID;
+			}
+		}
+
+	public:
+		// Typenames
+		typedef void(*CFunctionPointer)(Args...);
+
+		// Static members
+		// (none)
+
+		// Properties
+		// (none)
+
+		// Functions
+		EventHandler(std::function<void(Args...)> h) : _iterator(), handler(h), ID(++LastID)
+		{}
+
+		EventHandler(const EventHandler& ref){
+			_copy(ref);
+		}
+
+		virtual ~EventHandler(){};
+
+		EventHandler& operator=(const EventHandler& ref){
+			_copy(ref);
+			return *this;
+		}
+
+		void operator() (Args... args){
+			handler(args...);
+		}
+
+		bool operator==(const EventHandler& ref){
+			return ID == ref.ID;
+		}
+
+		bool operator!=(const EventHandler& ref){
+			return ID != ref.ID;
+		}
+
+		uint64_t getID(){
+			return ID;
+		}
+
+		// Returns function pointer to the underlying function
+		// or null if it's not a function but implements operator()
+		CFunctionPointer* getFunctionPointer(){
+			CFunctionPointer* ptr = handler.template target<CFunctionPointer>();
+			return ptr;
+		}
+	};
+
+	template<typename... Args>
+	uint64_t EventHandler<void(Args...)>::LastID = 0;
+
+
+	template <typename ... Args>
+	class Event<void(Args...)>
+	{
+		friend EventHandler<void(Args...)>;
+	private:
+		// Typenames
+		typedef typename std::list<EventHandler<void(Args...)>>::iterator ListIterator;
+
+		// Static members
+		// (none)
+
+		// Properties
+		std::list<EventHandler<void(Args...)>> handlers;
+
+		//Functions
+		void _copy(const Event& ref){
+			if (&ref != this){
+				handlers = ref.handlers;
+			}
+		};
+
+		bool removeHandler(ListIterator handlerIter)	{
+			if (handlerIter == handlers.end()){
+				return false;
+			}
+
+			handlers.erase(handlerIter);
+			return true;
+		};
+
+	public:
+		// Typenames
+		// (none)
+
+		// Static members
+		// (none)
+
+		// Properties
+		bool enabled;
+
+		// Functions
+		Event() : enabled(true)
+		{}
+
+		virtual ~Event() 
+		{}
+
+		Event(const Event& ref) 	{
+			_copy(ref);
+		}
+
+		void call(Args... args)	{
+			if (!enabled) { return; }
+			for (auto h = handlers.begin(); h != handlers.end(); h++)
+			{
+				(*h)(args...);
+			}
+		}
+
+		EventHandler<void(Args...)> registerHandler(EventHandler<void(Args...)> handler)	{
+			bool found = false;
+			for (auto h = handlers.begin(); h != handlers.end(); h++)
+			{
+				if ((*h) == handler)	{
+					found = true;
+					break;
+				}
+			}
+			if (!found)
+			{
+				ListIterator itr = handlers.insert(handlers.end(), handler);
+				handler._iterator = itr;
+			}
+			return handler;
+		}
+
+		EventHandler<void(Args...)> registerHandler(std::function<void(Args...)> handler)	{
+			EventHandler<void(Args...)> wrapper(handler);
+			ListIterator itr = handlers.insert(handlers.end(), wrapper);
+			wrapper._iterator = itr;
+			return wrapper;
+		}
+
+		bool removeHandler(EventHandler<void(Args...)>& handler)	{
+			bool sts = removeHandler(handler._iterator);
+			handler._iterator = handlers.end();
+			return sts;
+		};
+
+		void clear(){
+			for (auto h = handlers.begin(); h != handlers.end(); h++)
+			{
+				(*h)._iterator = handlers.end();
+			}
+			handlers.clear();
+		};
+
+		void operator ()(Args... args)													{ return call(args...); };
+		EventHandler<void(Args...)> operator +=(EventHandler<void(Args...)> handler)	{ return registerHandler(handler); };
+		EventHandler<void(Args...)> operator +=(std::function<void(Args...)> handler)	{ return registerHandler(handler); };
+		bool operator -=(EventHandler<void(Args...)>& handler)							{ return removeHandler(handler); };
+		bool operator -=(uint64_t handlerID)											{ return removeHandler(handlerID); };
+
+		EventHandler<void(Args...)>& operator =(const EventHandler<void(Args...)>& ref){
+			_copy(ref);
+			return *this;
+		};
+
+	};
+
+
+
+}
+
+#endif /* EVENT_H_ */