[seiscomp, scanloc] Install, add .gitignore

include/seiscomp/broker/client.h

@@ -0,0 +1,219 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_CLIENT_H__
+#define GEMPA_BROKER_CLIENT_H__
+
+
+#include <seiscomp/wired/devices/socket.h>
+#include <string>
+
+#include <seiscomp/broker/message.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Message;
+class Group;
+class Queue;
+
+
+/**
+ * @brief The Client interface describes a client connected to a queue acting
+ *        as message subscriber.
+ *
+ * The only thing that a client does is to store a name which is being assigned
+ * by the queue and publish messages. The publish method is abstract and needs
+ * to be implemented by derived classes such as communication protocols.
+ */
+class SC_BROKER_API Client {
+	// ----------------------------------------------------------------------
+	//  Public types and enumerations
+	// ----------------------------------------------------------------------
+	public:
+		enum Constants {
+			MaxLocalHeapSize = 128
+		};
+
+
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		//! C'tor
+		Client();
+
+		//! D'tor
+		virtual ~Client();
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		const std::string &name() const { return _name; }
+
+		/**
+		 * @brief Returns the absolute memory pointer of an local heap
+		 *        offset
+		 * @param offset The offset in bytes
+		 * @return The pointer of the memory block
+		 */
+		void *memory(int offset);
+		const void *memory(int offset) const;
+
+		/**
+		 * @return The time in UTC when the client has connected.
+		 */
+		const Core::Time &created() const;
+
+
+	// ----------------------------------------------------------------------
+	//  Subscriber interface
+	// ----------------------------------------------------------------------
+	public:
+		bool setMembershipInformationEnabled(bool enable);
+		bool wantsMembershipInformation() const;
+
+		/**
+		 * @brief Sets whether to discard messages where receiver equals
+		 *        the sender or not.
+		 * @param enable The enable flag
+		 * @return Success flag
+		 */
+		bool setDiscardSelf(bool enable);
+		bool discardSelf() const;
+
+		/**
+		 * @brief Sets the number of messages required to send back an
+		 *        acknoledgement.
+		 * @param numberOfMessages The window size
+		 */
+		void setAcknowledgeWindow(SequenceNumber numberOfMessages);
+
+		/**
+		 * @brief Returns the IP address connected to the client socket.
+		 *        If the underlying transport does not implement IP socket
+		 *        communication, it can return 0.
+		 * @return The IP address
+		 */
+		virtual Wired::Socket::IPAddress IPAddress() const = 0;
+
+		/**
+		 * @brief Publishes a message
+		 *
+		 * This method has to be implemented by all subclasses to encode it
+		 * into their transport format and to send it.
+		 *
+		 * @param sender The sender of the message
+		 * @param msg The message
+		 * @return Number of bytes sent
+		 */
+		virtual size_t publish(Client *sender, Message *msg) = 0;
+
+		/**
+		 * @brief Notifies a client that a new member entered a group the client
+		 *        is also member in.
+		 * @param group The group the new member entered.
+		 * @param newMember The client pointer to the new member.
+		 * @param msg The message to be sent.
+		 */
+		virtual void enter(const Group *group, const Client *newMember, Message *msg) = 0;
+
+		/**
+		 * @brief Notifies a client that a member left a group the client
+		 *        is also member in.
+		 * @param group The group the member left.
+		 * @param oldMember The client pointer to the member.
+		 * @param msg The message to be sent.
+		 */
+		virtual void leave(const Group *group, const Client *oldMember, Message *msg) = 0;
+
+		virtual void disconnected(const Client *disconnectedClient, Message *msg) = 0;
+
+		//! Send acknowledgment to sender
+		virtual void ack() = 0;
+
+		//! Remove the clients resources
+		virtual void dispose() = 0;
+
+
+	// ----------------------------------------------------------------------
+	//  Protected members
+	// ----------------------------------------------------------------------
+	protected:
+		Queue          *_queue{nullptr};
+		Core::Time      _created;
+		Core::Time      _lastSOHReceived;
+		std::string     _name;
+		bool            _wantsMembershipInformation{false};
+		bool            _discardSelf{false};
+		SequenceNumber  _sequenceNumber{0};
+		SequenceNumber  _acknowledgeWindow{20};
+		SequenceNumber  _acknowledgeCounter{20};
+		Core::Time      _ackInitiated;
+		int             _inactivityCounter{0}; // The number of seconds
+		                                       // of inactivity
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		// Local client heap to additional user data stored by e.g. plugins
+		char            _heap[MaxLocalHeapSize];
+
+	friend class Queue;
+};
+
+
+inline bool Client::wantsMembershipInformation() const {
+	return _wantsMembershipInformation;
+}
+
+inline bool Client::discardSelf() const {
+	return _discardSelf;
+}
+
+inline void *Client::memory(int offset) {
+	return _heap + offset;
+}
+
+inline const void *Client::memory(int offset) const {
+	return _heap + offset;
+}
+
+inline const Core::Time &Client::created() const {
+	return _created;
+}
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/group.h

@@ -0,0 +1,137 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_GROUP_H__
+#define GEMPA_BROKER_GROUP_H__
+
+
+#include <seiscomp/core/baseobject.h>
+#include <string>
+
+#include <seiscomp/broker/hashset.h>
+#include <seiscomp/broker/statistics.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Client;
+class Queue;
+
+
+DEFINE_SMARTPOINTER(Group);
+
+/**
+ * @brief The Group class implements a particular group (or channel/topic) of
+ *        a queue.
+ *
+ * Each group can have members. A member is a client. This class is nothing
+ * else than a manager of members in an efficient way. It implements a very
+ * fast hashset (KHash) of its members which makes member tests very fast and
+ * does not make it necessary to manage additional complicated lookup
+ * structures.
+ */
+class SC_BROKER_API Group : public Core::BaseObject {
+	// ----------------------------------------------------------------------
+	//  Public types
+	// ----------------------------------------------------------------------
+	public:
+		typedef KHashSet<Client*> Members;
+
+
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		//! C'tor
+		explicit Group(const char *name);
+
+		//! D'tor
+		~Group();
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		//! Returns the name of the group.
+		const std::string &name() const;
+
+		//! Returns the number of members.
+		size_t memberCount() const;
+
+		/**
+		 * @brief Adds a member to the group if it is not yet.
+		 * @param client The pointer identifying a unique client
+		 * @return true on success, false otherwise e.g. duplicates
+		 */
+		bool addMember(Client *client);
+
+		/**
+		 * @brief Removes a member from the group.
+		 * @param client The pointer identifying a unique client
+		 * @return true on success, false otherwise e.g. does not exist
+		 */
+		bool removeMember(Client *client);
+
+		//! Returns if a client is a member of not.
+		bool hasMember(const Client *client) const;
+
+		//! Removes all members.
+		void clearMembers() { _members.clear(); }
+
+		const Members &members() const;
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		std::string _name;
+		Members     _members;
+		mutable Tx  _txMessages;
+		mutable Tx  _txBytes;
+		mutable Tx  _txPayload;
+
+
+	friend class Queue;
+};
+
+
+inline const std::string &Group::name() const {
+	return _name;
+}
+
+inline const Group::Members &Group::members() const {
+	return _members;
+}
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/hashset.h

@@ -0,0 +1,666 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_HASHSET_H
+#define GEMPA_BROKER_HASHSET_H
+
+
+#include <stdint.h>
+#include <utility>
+#include <string>
+
+#include <seiscomp/broker/api.h>
+#include <seiscomp/broker/utils/khash.h>
+
+
+namespace Seiscomp {
+
+
+KHASH_SET_INIT_INT(int)
+KHASH_SET_INIT_INT64(int64)
+KHASH_SET_INIT_STR(str)
+KHASH_MAP_INIT_STR(m_str, void*)
+
+
+template <typename T>
+class KHashSet {};
+
+template <typename K, typename V>
+class KHashMap {};
+
+
+template <>
+class KHashSet<uint32_t> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(int) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			uint32_t operator*() const {
+				return kh_key(h, k);
+			}
+
+			khash_t(int) *h;
+			unsigned k;
+		};
+
+
+		KHashSet() {
+			_h = kh_init(int);
+		}
+
+		~KHashSet() {
+			kh_destroy(int, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(int, _h);
+		}
+
+		int insert(uint32_t v) {
+			int ret;
+			kh_put(int, _h, v, &ret);
+			return ret;
+		}
+
+		iterator find(uint32_t v) const {
+			return iterator(_h, kh_get(int, _h, v));
+		}
+
+		void erase(iterator it) {
+			kh_del(int, _h, it.k);
+		}
+
+		bool contains(uint32_t v) const {
+			return find(v) != end();
+		}
+
+
+	private:
+		khash_t(int) *_h;
+};
+
+
+template <>
+class KHashSet<uint64_t> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(int64) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			uint64_t operator*() const {
+				return kh_key(h, k);
+			}
+
+			khash_t(int64) *h;
+			unsigned k;
+		};
+
+
+		KHashSet() {
+			_h = kh_init(int64);
+		}
+
+		~KHashSet() {
+			kh_destroy(int64, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(int64, _h);
+		}
+
+		int insert(uint64_t v) {
+			int ret;
+			kh_put(int64, _h, v, &ret);
+			return ret;
+		}
+
+		iterator find(uint64_t v) const {
+			return iterator(_h, kh_get(int64, _h, v));
+		}
+
+		void erase(iterator it) {
+			kh_del(int64, _h, it.k);
+		}
+
+		bool contains(uint64_t v) const {
+			return find(v) != end();
+		}
+
+
+	private:
+		khash_t(int64) *_h;
+};
+
+
+template <>
+class KHashSet<const char*> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(str) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			const char *operator*() const {
+				return kh_key(h, k);
+			}
+
+			khash_t(str) *h;
+			unsigned k;
+		};
+
+
+		KHashSet() {
+			_h = kh_init(str);
+		}
+
+		~KHashSet() {
+			kh_destroy(str, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(str, _h);
+		}
+
+		int insert(const char *v) {
+			int ret;
+			kh_put(str, _h, v, &ret);
+			return ret;
+		}
+
+		iterator find(const char *str) const {
+			return iterator(_h, kh_get(str, _h, str));
+		}
+
+		iterator find(const std::string &str) const {
+			return iterator(_h, kh_get(str, _h, str.c_str()));
+		}
+
+		void erase(iterator it) {
+			kh_del(str, _h, it.k);
+		}
+
+		bool contains(const char *str) const {
+			return find(str) != end();
+		}
+
+		bool contains(const std::string &str) const {
+			return find(str) != end();
+		}
+
+
+	private:
+		khash_t(str) *_h;
+};
+
+
+template <typename V>
+class KHashMap<const char*, V*> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(m_str) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			const char *operator*() const {
+				return kh_key(h, k);
+			}
+
+			const char *key() const {
+				return kh_key(h, k);
+			}
+
+			V *value() const {
+				return (V*)kh_value(h, k);
+			}
+
+			khash_t(m_str) *h;
+			unsigned k;
+		};
+
+
+		KHashMap() {
+			_h = kh_init(m_str);
+		}
+
+		~KHashMap() {
+			kh_destroy(m_str, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(m_str, _h);
+		}
+
+		int insert(const char *v, V *value) {
+			int ret;
+			khiter_t k = kh_put(m_str, _h, v, &ret);
+			if ( k >= 0 )
+				kh_value(_h, k) = value;
+			return ret;
+		}
+
+		iterator find(const char *str) const {
+			return iterator(_h, kh_get(m_str, _h, str));
+		}
+
+		iterator find(const std::string &str) const {
+			return iterator(_h, kh_get(m_str, _h, str.c_str()));
+		}
+
+		void erase(iterator it) {
+			kh_del(m_str, _h, it.k);
+		}
+
+		bool contains(const char *str) const {
+			return find(str) != end();
+		}
+
+		bool contains(const std::string &str) const {
+			return find(str) != end();
+		}
+
+
+	private:
+		khash_t(m_str) *_h;
+};
+
+
+
+template <typename T, int BYTES>
+class KHashSetPtrBase {};
+
+
+template <typename T>
+class KHashSetPtrBase<T, 4> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(int) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			T operator*() const {
+				return (T)kh_key(h, k);
+			}
+
+			khash_t(int) *h;
+			unsigned k;
+		};
+
+
+	public:
+		KHashSetPtrBase() {
+			_h = kh_init(int);
+		}
+
+		~KHashSetPtrBase() {
+			kh_destroy(int, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(int, _h);
+		}
+
+		int insert(T v) {
+			int ret;
+			kh_put(int, _h, (uintptr_t)v, &ret);
+			return ret;
+		}
+
+		iterator find(const void *v) const {
+			return iterator(_h, kh_get(int, _h, (uintptr_t)v));
+		}
+
+		void erase(iterator it) {
+			kh_del(int, _h, it.k);
+		}
+
+		bool contains(const void *v) const {
+			return kh_get(int, _h, (uintptr_t)v) != kh_end(_h);
+		}
+
+
+	private:
+		khash_t(int) *_h;
+};
+
+
+template <typename T>
+class KHashSetPtrBase<T, 8> {
+	public:
+		struct iterator {
+			iterator() {}
+			iterator(const iterator &other) : h(other.h), k(other.k) {}
+			iterator(khash_t(int64) *h_, unsigned k_) : h(h_), k(k_) {}
+
+			bool operator==(const iterator &other) const {
+				return k == other.k;
+			}
+
+			bool operator!=(const iterator &other) const {
+				return k != other.k;
+			}
+
+			// Prefix
+			iterator &operator++() {
+				++k;
+				while ( k != kh_end(h) && !kh_exist(h, k) )
+					++k;
+
+				return *this;
+			}
+
+			// Postfix
+			iterator operator++(int) {
+				iterator tmp(*this);
+				++(*this);
+				return tmp;
+			}
+
+			T operator*() const {
+				return (T)kh_key(h, k);
+			}
+
+			khash_t(int64) *h;
+			unsigned k;
+		};
+
+
+	public:
+		KHashSetPtrBase() {
+			_h = kh_init(int64);
+		}
+
+		~KHashSetPtrBase() {
+			kh_destroy(int64, _h);
+		}
+
+
+	public:
+		iterator begin() const {
+			unsigned k = kh_begin(_h);
+			while ( k != kh_end(_h) && !kh_exist(_h, k) )
+				++k;
+			return iterator(_h, k);
+		}
+
+		iterator end() const {
+			return iterator(_h, kh_end(_h));
+		}
+
+		size_t size() const {
+			return kh_size(_h);
+		}
+
+		void clear() {
+			kh_clear(int64, _h);
+		}
+
+		int insert(T v) {
+			int ret;
+			kh_put(int64, _h, (uintptr_t)v, &ret);
+			return ret;
+		}
+
+		iterator find(const void *v) const {
+			return iterator(_h, kh_get(int64, _h, (uintptr_t)v));
+		}
+
+		void erase(iterator it) {
+			kh_del(int64, _h, it.k);
+		}
+
+		bool contains(const void *v) const {
+			return kh_get(int64, _h, (uintptr_t)v) != kh_end(_h);
+		}
+
+
+	private:
+		khash_t(int64) *_h;
+};
+
+
+struct Arch {
+	enum {
+		PtrSize = sizeof(intptr_t)
+	};
+};
+
+
+template <typename T>
+class KHashSet<T*> : public KHashSetPtrBase<T*, Arch::PtrSize> {
+	public:
+		KHashSet() {}
+};
+
+
+}
+
+
+#endif

include/seiscomp/broker/message.h

@@ -0,0 +1,164 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_MESSAGE_H__
+#define GEMPA_BROKER_MESSAGE_H__
+
+
+#include <string>
+#include <stdint.h>
+
+#include <seiscomp/core/enumeration.h>
+#include <seiscomp/wired/buffer.h>
+
+#include <seiscomp/broker/api.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Group;
+
+
+typedef uint64_t SequenceNumber;
+#define INVALID_SEQUENCE_NUMBER Seiscomp::Messaging::Broker::SequenceNumber(-1)
+
+
+MAKEENUM(
+	ContentEncoding,
+	EVALUES(
+		Identity,
+		Deflate,
+		GZip,
+		LZ4
+	),
+	ENAMES(
+		"identity",
+		"deflate",
+		"gzip",
+		"lz4"
+	)
+);
+
+MAKEENUM(
+	MimeType,
+	EVALUES(
+		Binary,
+		JSON,
+		BSON,
+		XML,
+		IMPORTED_XML,
+		Text
+	),
+	ENAMES(
+		"application/x-sc-bin",
+		"text/json",
+		"application/x-sc-bson",
+		"application/x-sc-xml",
+		"text/xml",
+		"text/plain"
+	)
+);
+
+
+DEFINE_SMARTPOINTER(Message);
+/**
+ * @brief The Message class implements the message structure.
+ *
+ * A message contains meta data and a payload. Since each protocol has to
+ * encode the message differently a cached version for each protocol is also
+ * stored. That buffer can be sent without further modifications. This is
+ * in particular helpful if a message is going to be sent to hundreds of
+ * clients connected through the same protocol. The message has to be encoded
+ * only once and not hundred times. This cache is lazy and will only be
+ * populated at the first send operation.
+ */
+class SC_BROKER_API Message : public Seiscomp::Core::BaseObject {
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		//! C'tor
+		Message();
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @brief Decodes a message if object is NULL according to the payload
+		 *        and format
+		 * @return true if msg->object is a valid pointer or false otherwise.
+		 */
+		bool decode();
+
+		/**
+		 * @brief Encodes a message if object is not NULL and saves the
+		 *        encoded buffer in payload.
+		 * @return true if payload is not empty, false otherwise.
+		 */
+		bool encode();
+
+
+	// ----------------------------------------------------------------------
+	//  Members
+	// ----------------------------------------------------------------------
+	public:
+		enum struct Type {
+			Unspecified,
+			Regular,
+			Transient, // From this enumeration messages are not processed
+			Status
+		};
+
+		std::string                   sender;      //!< The sender
+		std::string                   target;      //!< The target group/topic
+		std::string                   encoding;    //!< The encoding of the data
+		std::string                   mimeType;    //!< The mime type of the data
+		std::string                   payload;     //!< The payload bytes
+		Core::BaseObjectPtr           object;      //!< The decoded object
+		Core::Version                 schemaVersion; //!< The schema version of the payload after decoding
+		Seiscomp::Core::Time          timestamp;   //!< The received time
+		Type                          type; //!< The message type
+		bool                          selfDiscard; //!< Whether self discard should be checked or not
+		bool                          processed;
+		/** The assigned sequence number */
+		SequenceNumber                sequenceNumber;
+
+		/** Cached encoded version for different protocols */
+		Wired::BufferPtr              encodingWebSocket;
+
+		/** Cache of the target group */
+		Group                         *_internalGroupPtr;
+};
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/messagedispatcher.h

@@ -0,0 +1,94 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_MESSAGEDISPATCHER_H__
+#define GEMPA_BROKER_MESSAGEDISPATCHER_H__
+
+
+#include <seiscomp/broker/api.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Client;
+class Message;
+class Queue;
+
+
+/**
+ * @brief The MessageDispatcher class is used to forward processed messages
+ *        from another thread.
+ *
+ * Since it is not safe to call publish on all registered subscribers, the
+ * dispatcher class is provide safe handling within a given framework.
+ */
+class SC_BROKER_API MessageDispatcher {
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		//! C'tor
+		MessageDispatcher() {}
+
+
+	// ----------------------------------------------------------------------
+	//  Dispatcher interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @brief Sends a message thread-safe.
+		 * @param sender The sender of the message
+		 * @param message The message itself which must not be managed
+		 *                by the caller.
+		 */
+		virtual void sendMessage(Client *sender, Message *message) = 0;
+
+		/**
+		 * @brief Notifies the dispatcher about a new message. If the message
+		 *        should be published, dispatch() must be called.
+		 * @param queue The queue that got a new message to be dispatched
+		 */
+		virtual void messageAvailable(Queue *queue) = 0;
+
+		/**
+		 * @brief Dispatches a message from the process-ready-queue.
+		 *
+		 * This call may block if not issued after the messageAvailable()
+		 * signal.
+		 * @param queue The target queue
+		 */
+		void flushMessages(Queue *queue) {
+			queue->flushProcessedMessages();
+		}
+};
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/messageprocessor.h

@@ -0,0 +1,145 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_MESSAGEPROCESSOR_H__
+#define GEMPA_BROKER_MESSAGEPROCESSOR_H__
+
+
+#include <string>
+#include <ostream>
+
+#include <seiscomp/core/baseobject.h>
+#include <seiscomp/core/interfacefactory.h>
+#include <seiscomp/config/config.h>
+
+#include <seiscomp/broker/processor.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Client;
+class Message;
+
+
+DEFINE_SMARTPOINTER(MessageProcessor);
+
+/**
+ * @brief The MessageProcessor class is used inside the broker to process
+ *        messages in any way. The most important use case for such a
+ *        processor is to store the message in the database if it suffices a
+ *        certain format. Once could think of other use cases such as
+ *        building statistics.
+ */
+class SC_BROKER_API MessageProcessor : public Processor {
+	// ----------------------------------------------------------------------
+	//  Public types
+	// ----------------------------------------------------------------------
+	public:
+		enum Constants {
+			MaxAdditionalParams = 100
+		};
+
+		enum Mode {
+			None        = 0x00,
+			Messages    = 0x01,
+			Connections = 0x02
+		};
+
+		using KeyValueCStrPair = std::pair<const char*,const char*>;
+		using KeyCStrValues = KeyValueCStrPair *;
+
+		using KeyValuePair = std::pair<std::string,std::string>;
+		using KeyValues = std::vector<KeyValuePair>;
+
+
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		MessageProcessor();
+		virtual ~MessageProcessor();
+
+
+	// ----------------------------------------------------------------------
+	//  Public virtual interface
+	// ----------------------------------------------------------------------
+	public:
+		virtual bool acceptConnection(Client *client,
+		                              const KeyCStrValues inParams, int inParamCount,
+		                              KeyValues &outParams) = 0;
+
+		virtual void dropConnection(Client *client) = 0;
+
+		virtual bool process(Message *msg) = 0;
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		int mode() const { return _mode; }
+
+		/**
+		 * @brief Returns whether the processor want to process messages.
+		 * @return Flag
+		 */
+		bool isMessageProcessingEnabled() const { return _mode & Messages; }
+
+		/**
+		 * @brief Returns whether the processor want to process connections..
+		 * @return Flag
+		 */
+		bool isConnectionProcessingEnabled() const { return _mode & Connections; }
+
+
+	// ----------------------------------------------------------------------
+	//  Protected methods
+	// ----------------------------------------------------------------------
+	protected:
+		void setMode(int mode);
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		int _mode;
+};
+
+
+DEFINE_INTERFACE_FACTORY(MessageProcessor);
+
+
+}
+}
+}
+
+
+#define REGISTER_BROKER_MESSAGE_PROCESSOR(Class, Service) \
+Seiscomp::Core::Generic::InterfaceFactory<Seiscomp::Messaging::Broker::MessageProcessor, Class> __##Class##InterfaceFactory__(Service)
+
+
+#endif

include/seiscomp/broker/processor.h

@@ -0,0 +1,103 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_PROCESSOR_H__
+#define GEMPA_BROKER_PROCESSOR_H__
+
+
+#include <seiscomp/core/baseobject.h>
+#include <seiscomp/config/config.h>
+
+#include <seiscomp/broker/api.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Queue;
+
+
+DEFINE_SMARTPOINTER(Processor);
+
+class SC_BROKER_API Processor : public Core::BaseObject {
+	public:
+		Processor();
+		virtual ~Processor();
+
+
+	public:
+		/**
+		 * @brief Initiales the configuration of a processor from a config object
+		 *        and a given parameter name prefix.
+		 * @param conf The configuration file object
+		 * @param configPrefix The prefix that must be preprended to all
+		 *                     parameters.
+		 * @return Success flag.
+		 */
+		virtual bool init(const Config::Config &conf, const std::string &configPrefix) = 0;
+
+		/**
+		 * @brief When a processor has been added to a queue, this method will be
+		 *        called. The default implementation does nothing. This method
+		 *        can be used to e.g. allocate additional client memory of
+		 *        the local client heap.
+		 * @param queue The queue the processor was attached to.
+		 */
+		virtual bool attach(Queue *queue);
+
+		/**
+		 * @brief Shuts down the processor.
+		 * @return Success flag.
+		 */
+		virtual bool close() = 0;
+
+		/**
+		 * @brief Add information to a state of health message
+		 * @param timestamp The timestamp of the information
+		 * @param os The output stream to write to
+		 */
+		virtual void getInfo(const Core::Time &timestamp, std::ostream &os) = 0;
+
+		Queue *queue() const;
+
+
+	private:
+		Queue *_queue;
+
+	friend class Queue;
+};
+
+
+inline Queue *Processor::queue() const {
+	return _queue;
+}
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/protocol.h

@@ -0,0 +1,343 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_BROKER_PROTOCOL_H__
+#define GEMPA_BROKER_PROTOCOL_H__
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+namespace Protocol {
+
+
+// Defines do not make much sense inside namespaces but they are placed here
+// to stay close to future variable declarations.
+
+/**
+ * It follows a list of definitions for all protocol commands and replies and
+ * their headers. They are being used in the code and changing them here will
+ * cause a change in behaviour of the server.
+ */
+
+/**
+ * ```
+ * CONNECT
+ * Ack-Window: [number of messages after which an ack will be send from the server]
+ * Membership-Info: 1
+ * Queue: [name of queue]
+ * Client-Name: [name of client]
+ * Subscriptions: [list of groups]
+ * Seq-No: [last seen sequence number]
+ *
+ * ^@
+ * ```
+ *
+ * The *Seq-No* header contains the last sequence number the client has seen from
+ * that queue. That header is optional. If subscriptions are given then the
+ * client will receive an **ENTER** frame for each group it subscribed to. If any
+ * of the requested groups does not exist, an **ERROR** frame is sent and the
+ * connection is closed.
+ *
+ * The order of messages looks as follows:
+ *
+ * 1. CONNECT
+ * 2. CONNECTED
+ * 3. ENTER
+ * 4. RECV
+ *
+ * Step 3 repeats for as many groups as given in the subscription list. Step 4
+ * repeats for all messages received during the lifetime of the connection.
+ */
+#define SCMP_PROTO_CMD_CONNECT        "CONNECT"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_QUEUE           "Queue"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_CLIENT_NAME     "Client-Name"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_MEMBERSHIP_INFO "Membership-Info"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_SELF_DISCARD    "Self-Discard"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_ACK_WINDOW      "Ack-Window"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_SEQ_NUMBER      "Seq-No"
+#define SCMP_PROTO_CMD_CONNECT_HEADER_SUBSCRIPTIONS   "Subscriptions"
+
+/**
+ * ```
+ * DISCONNECT
+ * Receipt: [id]
+ *
+ * ^@
+ * ```
+ *
+ * The DISCONNECT command ask the server to gracefully shutdown the connection
+ * and free all associated resources.
+ */
+#define SCMP_PROTO_CMD_DISCONNECT     "DISCONNECT"
+#define SCMP_PROTO_CMD_DISCONNECT_HEADER_RECEIPT      "Receipt"
+
+/**
+ * ```
+ * SUBSCRIBE
+ * Groups: [list of groups]
+ *
+ * ^@
+ * ```
+ * Subscribes to a specific group which must exist on the server. In response
+ * either an **ENTER** or **ERROR** frame will be received.
+ */
+#define SCMP_PROTO_CMD_SUBSCRIBE      "SUBSCRIBE"
+#define SCMP_PROTO_CMD_SUBSCRIBE_HEADER_GROUPS        "Groups"
+
+/**
+ * ```
+ * UNSUBSCRIBE
+ * Groups: [list of groups]
+ *
+ * ^@
+ * ```
+ *
+ * Unsubscribes from a specific group which must exist on the server. In
+ * response either a **LEAVE** or **ERROR** frame will be received.
+ */
+#define SCMP_PROTO_CMD_UNSUBSCRIBE    "UNSUBSCRIBE"
+#define SCMP_PROTO_CMD_UNSUBSCRIBE_HEADER_GROUPS      SCMP_PROTO_CMD_SUBSCRIBE_HEADER_GROUPS
+
+/**
+ * Sends a message to a group or a client (peer-to-peer).
+ *
+ * ```
+ * SEND
+ * D: [name of group or the client]
+ * T: [MIME type]
+ * E: [transfer encoding]
+ * L: [length of content]
+ *
+ * [payload]^@
+ * ```
+ *
+ * Each message sent will increase the private sequence number counter for this
+ * connection starting with 0. So the first message will get assigned the
+ * sequence number 1. That counter must be maintained by the client and the
+ * server to correctly synchronize acknowledgements. If the message is rejected
+ * an **ERROR** frame will be sent to the client and the connection will be
+ * closed.
+ */
+#define SCMP_PROTO_CMD_SEND           "SEND"
+#define SCMP_PROTO_CMD_SEND_HEADER_DESTINATION        "D"
+#define SCMP_PROTO_CMD_SEND_HEADER_CONTENT_LENGTH     "L"
+#define SCMP_PROTO_CMD_SEND_HEADER_ENCODING           "E"
+#define SCMP_PROTO_CMD_SEND_HEADER_MIMETYPE           "T"
+#define SCMP_PROTO_CMD_SEND_HEADER_TRANSIENT          "Transient"
+
+
+/**
+ * A member notifies the server about its state including memory consumption,
+ * cpu usage, uptime and so on. The payload is always a key-value list
+ * separated by '&'.
+ *
+ * ```
+ * STATE
+ * D: [name of group or the client]
+ * L: [length of content]
+ *
+ * hostname=localhost&totalmemory=8589934592&clientmemoryusage=68891443...^@
+ * ```
+ */
+#define SCMP_PROTO_CMD_STATE        "STATE"
+#define SCMP_PROTO_CMD_STATE_HEADER_DESTINATION       "D"
+#define SCMP_PROTO_CMD_STATE_HEADER_CONTENT_LENGTH    "L"
+
+#define SCMP_PROTO_CMD_FIRST_CHARS  "CDSU"
+
+/**
+ * ```
+ * CONNECTED
+ * Queue: [name of queue]
+ * Server: SeisComP/2017.334
+ * Version: [server protocol version]
+ * Client-Name: [client name, either auto assigned or requested by the client]
+ * Authentication: [16 byte hex random NaCL nonce prefix]
+ *                 [32 byte hex NaCL public server key]
+ *                 [16 byte hex encrypted buffer: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"]
+ * Groups: [list of available groups]
+ *
+ * ^@
+ * ```
+ *
+ * In return to a **CONNECT** frame the server responds with a **CONNECTED**
+ * frame. It reports the client name in use for this connection and a list of
+ * available groups.
+ */
+#define SCMP_PROTO_REPLY_CONNECT      "CONNECTED"
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_VERSION        "Version"
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_SCHEMA_VERSION "Schema-Version"
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_QUEUE          SCMP_PROTO_CMD_CONNECT_HEADER_QUEUE
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_CLIENT_NAME    SCMP_PROTO_CMD_CONNECT_HEADER_CLIENT_NAME
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_ACK_WINDOW     SCMP_PROTO_CMD_CONNECT_HEADER_ACK_WINDOW
+#define SCMP_PROTO_REPLY_CONNECT_HEADER_GROUPS         "Groups"
+
+/**
+ * The probably most important part of the protocol is receiving a message from
+ * a group or a client (peer-to-peer).
+ *
+ * ```
+ * RECV
+ * C: [client name of sender]
+ * D: [name of group or the client]
+ * T: [MIME type]
+ * E: [transfer encoding]
+ * N: [message sequence number]
+ * L: [length of content]
+ *
+ * [payload]^@
+ * ```
+ *
+ * The payload can be anything, binary data or text. Optionally the *Content-Type*
+ * header is set to inform the client about the format.
+ */
+#define SCMP_PROTO_REPLY_SEND         "RECV"
+#define SCMP_PROTO_REPLY_SEND_HEADER_SENDER           "C"
+#define SCMP_PROTO_REPLY_SEND_HEADER_SEQ_NUMBER       "N"
+#define SCMP_PROTO_REPLY_SEND_HEADER_DESTINATION      SCMP_PROTO_CMD_SEND_HEADER_DESTINATION
+#define SCMP_PROTO_REPLY_SEND_HEADER_CONTENT_LENGTH   SCMP_PROTO_CMD_SEND_HEADER_CONTENT_LENGTH
+#define SCMP_PROTO_REPLY_SEND_HEADER_ENCODING         SCMP_PROTO_CMD_SEND_HEADER_ENCODING
+#define SCMP_PROTO_REPLY_SEND_HEADER_MIMETYPE         SCMP_PROTO_CMD_SEND_HEADER_MIMETYPE
+
+/**
+ * ```
+ * ACK
+ * N: [connection specific sequence number]
+ *
+ * ^@
+ * ```
+ *
+ * The server sends according to the configured acknoledgement window an
+ * acknowledgement frame to signal that all messages prior to the given sequence
+ * number have been processed and that the current sequence number is expected
+ * to be the one sent. It will do that as well after 1 second the client
+ * hasn't sent any further messages.
+ */
+#define SCMP_PROTO_REPLY_ACK          "ACK"
+#define SCMP_PROTO_REPLY_ACK_HEADER_SEQ_NUMBER        SCMP_PROTO_REPLY_SEND_HEADER_SEQ_NUMBER
+
+/**
+ * ```
+ * RECEIPT
+ * Receipt-Id: [id]
+ *
+ * ^@
+ * ```
+ *
+ * A receipt can basically be sent for anything which has an id. A receipt is
+ * being sent definitely after a disconnect request. In that case the receipt
+ * id is the username.
+ */
+#define SCMP_PROTO_REPLY_RECEIPT      "RECEIPT"
+#define SCMP_PROTO_REPLY_RECEIPT_HEADER_ID            "Receipt-Id"
+
+/**
+ * A members enters a group. In response to a **SUBSCRIBE** command, the complete
+ * group information will be sent to the client. Specifically if
+ * ```Member == self```. Otherwise only the group and member information will be
+ * sent from the server to all clients that are subscribed to that group. The
+ * client needs to update its internal cache and the frame body is empty in that
+ * case.
+ *
+ * ```
+ * ENTER
+ * D: [name of group]
+ * C: [name of client]
+ *
+ * clientA, clientB, ...
+ * }^@
+ * ```
+ */
+#define SCMP_PROTO_REPLY_ENTER        "ENTER"
+#define SCMP_PROTO_REPLY_ENTER_HEADER_GROUP           "D"
+#define SCMP_PROTO_REPLY_ENTER_HEADER_MEMBER          "C"
+
+/**
+ * A member leaves a group. This message will sent from the server to all clients
+ * that are subscribed to the group in question.
+ *
+ * ```
+ * LEAVE
+ * D: [name of group]
+ * C: [name of client]
+ *
+ * ^@
+ * ```
+ */
+#define SCMP_PROTO_REPLY_LEAVE        "LEAVE"
+#define SCMP_PROTO_REPLY_LEAVE_HEADER_GROUP           SCMP_PROTO_REPLY_ENTER_HEADER_GROUP
+#define SCMP_PROTO_REPLY_LEAVE_HEADER_MEMBER          SCMP_PROTO_REPLY_ENTER_HEADER_MEMBER
+
+/**
+ * A member state of health information or simply its state including
+ * memory consumption, cpu usage, uptime and so on. The payload is always
+ * a key-value list separated by '&'.
+ *
+ * ```
+ * STATE
+ * L: [length of content]
+ * D: [name of group or the client]
+ * C: [name of client]
+ *
+ * hostname=localhost&totalmemory=8589934592&clientmemoryusage=68891443...^@
+ * ```
+ */
+#define SCMP_PROTO_REPLY_STATE        "STATE"
+#define SCMP_PROTO_REPLY_STATE_HEADER_DESTINATION     "D"
+#define SCMP_PROTO_REPLY_STATE_HEADER_CLIENT          "C"
+#define SCMP_PROTO_REPLY_STATE_HEADER_CONTENT_LENGTH  SCMP_PROTO_CMD_SEND_HEADER_CONTENT_LENGTH
+
+/**
+ * A client was disconnected. This message will sent from the server to all
+ * clients currently connected.
+ *
+ * ```
+ * DISCONNECTED
+ * C: [name of client]
+ *
+ * ^@
+ * ```
+ */
+#define SCMP_PROTO_REPLY_DISCONNECTED "DISCONNECTED"
+#define SCMP_PROTO_REPLY_DISCONNECTED_HEADER_CLIENT   SCMP_PROTO_REPLY_STATE_HEADER_CLIENT
+
+/**
+ * ```
+ * ERROR
+ * N: [connection specific sequence number]
+ *
+ * Error message ...^@
+ * ```
+ */
+#define SCMP_PROTO_REPLY_ERROR        "ERROR"
+#define SCMP_PROTO_REPLY_ERROR_HEADER_SEQ_NUMBER      SCMP_PROTO_REPLY_SEND_HEADER_SEQ_NUMBER
+
+
+}
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/queue.h

@@ -0,0 +1,419 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef SEISCOMP_BROKER_QUEUE_H__
+#define SEISCOMP_BROKER_QUEUE_H__
+
+
+#include <seiscomp/core/enumeration.h>
+#include <seiscomp/core/message.h>
+
+#include <seiscomp/broker/messageprocessor.h>
+#include <seiscomp/broker/hashset.h>
+#include <seiscomp/broker/group.h>
+#include <seiscomp/broker/message.h>
+#include <seiscomp/broker/statistics.h>
+
+#include <seiscomp/broker/utils/utils.h>
+#include <seiscomp/broker/utils/circular.h>
+
+#include <thread>
+#include <vector>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+class Client;
+class MessageDispatcher;
+
+DEFINE_SMARTPOINTER(MessageProcessor);
+
+
+/**
+ * @brief The Queue class implements the central messaging service.
+ *
+ * The Queue receives messages, queues them and distributes them to subscribed
+ * clients.
+ */
+class SC_BROKER_API Queue {
+	// ----------------------------------------------------------------------
+	//  Public types
+	// ----------------------------------------------------------------------
+	public:
+		using StringList = std::vector<std::string>;
+		using MessageProcessors = std::vector<MessageProcessorPtr>;
+
+		using KeyValueCStrPair = MessageProcessor::KeyValueCStrPair;
+		using KeyCStrValues = MessageProcessor::KeyCStrValues;
+
+		using KeyValuePair = MessageProcessor::KeyValuePair;
+		using KeyValues = MessageProcessor::KeyValues;
+
+		enum Constants {
+			MaxAdditionalParams = MessageProcessor::MaxAdditionalParams
+		};
+
+		MAKEENUM(
+			Result,
+			EVALUES(
+				Success,
+				InternalError,
+				ClientNameNotUnique,
+				ClientNotAccepted,
+				GroupNameNotUnique,
+				GroupDoesNotExist,
+				GroupAlreadySubscribed,
+				GroupNotSubscribed,
+				MessageNotAccepted,
+				MessageDecodingFailed,
+				MessageEncodingFailed,
+				NotEnoughClientHeap
+			),
+			ENAMES(
+				"Success",
+				"Internal error",
+				"Client name is not unique",
+				"Client was not accepted",
+				"Group name is not unique",
+				"Group does not exist",
+				"Already subscribed to group",
+				"Not subscribed to group",
+				"Message not accepted",
+				"Message could not be decoded",
+				"Message could not be encoded",
+				"Not enough client heap"
+			)
+		);
+
+		const std::string StatusGroup = "STATUS_GROUP";
+
+
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		//! C'tor
+		Queue(const std::string &name, uint64_t maxPayloadSize);
+		~Queue();
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @return The queue name
+		 */
+		const std::string &name() const;
+
+		/**
+		 * @brief Adds a message processor to the list of processors.
+		 * @param proc The processor instance which is managed by the queue
+		 *             with a smart pointer.
+		 * @return Success flag
+		 */
+		bool add(MessageProcessor *proc);
+
+		/**
+		 * @brief Adds a group/topic to the queue.
+		 * @param name The name of the group
+		 * @return true on success, false otherwise
+		 */
+		Result addGroup(const std::string &name);
+
+		/**
+		 * @brief Returns a list of available group names
+		 * @return The list of names
+		 */
+		const StringList &groups() const { return _groupNames; }
+
+		/**
+		 * @brief Return the sender name of the queue.
+		 * @return A NULL terminated const string
+		 */
+		const char *senderName() const;
+
+		/**
+		 * @brief Sets the message dispatcher for thread synchronisation.
+		 *
+		 * The queue runs a thread to process messages via plugins. If the
+		 * message is processed the thread notifies the queue about it. The
+		 * queue could now call publish but that is probably not thread-safe
+		 * and inefficient to implement on each subscriber. The message
+		 * dispatcher receives a notification about a new message and can then
+		 * implement any inter-thread communication to publish the message in
+		 * the same context as it has been created.
+		 *
+		 * @param dispatcher The dispatcher instance not managed by the queue.
+		 */
+		void setMessageDispatcher(MessageDispatcher *dispatcher);
+
+		/**
+		 * @brief Subscribe a client to a particular group
+		 * @param client The client
+		 * @param group The name of the group
+		 * @return The result code
+		 */
+		Result subscribe(Client *client, const std::string &group);
+
+		/**
+		 * @brief Unsubscribes a client from a particular group
+		 * @param client The client
+		 * @param group The name of the group
+		 * @return The result code
+		 */
+		Result unsubscribe(Client *client, const std::string &group);
+
+		/**
+		 * @brief Returns a buffered message after a particular sequence number
+		 * @param sequenceNumber The sequence number to continue with.
+		 *
+		 *        The returned message must have a sequence number greater than
+		 *        this parameter or lower if a wrap has occured but never the
+		 *        same.
+		 * @param client The client instance to filter subscriptions for
+		 * @return A message pointer or NULL if no message is available
+		 */
+		Message *getMessage(SequenceNumber sequenceNumber,
+		                    const Client *client) const;
+
+		/**
+		 * @brief Pushes a message from a client to the queue
+		 *
+		 * This method is called from Client subclasses that received a message
+		 * through their transport protocol. The message pointer will either
+		 * be managed in a smart pointer or deleted. If false is returned the
+		 * caller must take care of deleting the message.
+		 *
+		 * @param sender The sender instance
+		 * @param msg The message
+		 * @param packetLength The size in bytes of the received packet including
+		 *                     protocol specific header data. This is only
+		 *                     used for statistics.
+		 * @return The result code
+		 */
+		Result push(Client *sender, Message *msg, int packetSize = 0);
+
+		/**
+		 * @brief Dispatches a message via a message dispatcher. If none is
+		 *        set then this call is equal to push.
+		 * @param sender The sender instance
+		 * @param msg The message
+		 * @return The result code
+		 */
+		Result dispatch(Client *sender, Message *msg);
+
+		/**
+		 * @brief Activates the queue and starts the processing thread.
+		 */
+		void activate();
+
+		/**
+		 * @brief Shutdown the queue and finished the processing thread if
+		 *        running.
+		 *
+		 * This will also shutdown all processors associated with the queue.
+		 *
+		 * Note that this call can block depending how many plugins are
+		 * running and currently processing a message. This method waits until
+		 * the processing thread is finished.
+		 */
+		void shutdown();
+
+		/**
+		 * @brief Callback to notify the queue about some timeout.
+		 *
+		 * This function is used to check expiration of outstanding
+		 * acknowledgement messages. This function is not thread-safe and
+		 * must be called from within the thread the queue is running in.
+		 */
+		void timeout();
+
+		/**
+		 * @brief Populates the passed statistics structure.
+		 * @param stats[out] The target structure
+		 * @param reset[in] Whether to reset the internal statistics or not.
+		 */
+		void getStatisticsSnapshot(QueueStatistics &stats, bool reset = true);
+
+
+	// ----------------------------------------------------------------------
+	//  Client memory interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @brief Allocates additional client heap. Once allocated the heap
+		 *        cannot be free'd anymore. This is mainly used for plugins
+		 *        that are initialized once and need to store additional
+		 *        data in a client structure.
+		 * @param bytes The number of bytes to allocate
+		 * @return An offset to the local client heap or a negative number
+		 *         in case of an error. The absolute value (-result) of the
+		 *         error translates to a status code (@Result).
+		 */
+		int allocateClientHeap(int bytes);
+
+
+	// ----------------------------------------------------------------------
+	//  Publisher interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @brief Registers a client in the queue and sets up the PubSub
+		 *        connections.
+		 *
+		 * This is called when the client calls connect and is part of the
+		 * PublisherBase interface.
+		 * @param client The client to be registered
+		 * @param slot The slot
+		 * @return The result code
+		 */
+		Result connect(Client *client, const KeyCStrValues params, int paramCount,
+		               KeyValues &outParams);
+
+		/**
+		 * @brief Deregisters a client from the queue and clears the PubSub
+		 *        connections.
+		 *
+		 * This is called when the client calls disconnect and is part of the
+		 * PublisherBase interface.
+		 * @param client The client to be deregistered
+		 * @return The result code
+		 */
+		Result disconnect(Client *client);
+
+
+	// ----------------------------------------------------------------------
+	//  Settings interface
+	// ----------------------------------------------------------------------
+	public:
+		uint64_t maxPayloadSize() const;
+
+
+	// ----------------------------------------------------------------------
+	//  Private interface
+	// ----------------------------------------------------------------------
+	private:
+		using ProcessingTask = std::pair<Client*,Message*>;
+		using TaskQueue = Utils::BlockingDequeue<ProcessingTask>;
+
+		/**
+		 * @brief Publishes a message from a client to all registered clients
+		 *
+		 * This method is called from Client subclasses that received a message
+		 * through their transport protocol.
+		 *
+		 * @param sender The sender instance
+		 * @param msg The message
+		 * @return true on success, false otherwise
+		 */
+		bool publish(Client *sender, Message *msg);
+
+		/**
+		 * @brief Pops all messages from the processing queue and publishes them.
+		 *
+		 * This call does not block.
+		 */
+		void flushProcessedMessages();
+
+		/**
+		 * @brief The processing loop running in a different thread.
+		 */
+		void processingLoop();
+
+		/**
+		 * @brief Processes a message e.g. via plugins.
+		 * @param task The task to be processed
+		 */
+		void process(ProcessingTask &task);
+
+		/**
+		 * @brief Called from the processing thread informing the queue that
+		 *        the message is processed and can be forwarded to clients.
+		 * @param task The task
+		 */
+		void taskReady(const ProcessingTask &task);
+
+		/**
+		 * @brief Replaces the incoming message with a response
+		 * @param task The task to be updated
+		 */
+		void returnToSender(Message *msg, Core::BaseObject *obj);
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		using Groups = std::map<std::string, GroupPtr>;
+		using MessageRing = circular_buffer<MessagePtr>;
+		using ClientNames = KHashSet<const char*>;
+		using Clients = KHashMap<const char*, Client*>;
+
+		std::string          _name;
+		MessageProcessors    _processors;
+		MessageProcessors    _connectionProcessors;
+		MessageProcessors    _messageProcessors;
+		MessageDispatcher   *_processedMessageDispatcher;
+		SequenceNumber       _sequenceNumber;
+		Groups               _groups;
+		StringList           _groupNames;
+		MessageRing          _messages;
+		Clients              _clients;
+		std::thread         *_messageProcessor;
+		TaskQueue            _tasks;
+		TaskQueue            _results;
+		Core::Time           _created;
+		Core::Time           _lastSOHTimestamp;
+		int                  _allocatedClientHeap;
+		int                  _sohInterval;
+		int                  _inactivityLimit;
+		uint64_t             _maxPayloadSize;
+		mutable Tx           _txMessages;
+		mutable Tx           _txBytes;
+		mutable Tx           _txPayload;
+
+
+	friend class MessageDispatcher;
+};
+
+
+inline const std::string &Queue::name() const {
+	return _name;
+}
+
+
+inline uint64_t Queue::maxPayloadSize() const {
+	return _maxPayloadSize;
+}
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/statistics.h

@@ -0,0 +1,109 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef SEISCOMP_BROKER_STATISTICS_H__
+#define SEISCOMP_BROKER_STATISTICS_H__
+
+
+#include <seiscomp/core/baseobject.h>
+#include <seiscomp/broker/api.h>
+
+
+namespace Seiscomp {
+namespace Messaging {
+namespace Broker {
+
+
+/**
+ * @brief Simple structure to store transfer counts.
+ * The unit of the counters is not defined. It can be counts or
+ * bytes or something different. That depends on the context.
+ */
+struct SC_BROKER_API Tx : Core::BaseObject {
+	Tx() : received(0), sent(0) {}
+
+	double received; //!< Number of items received
+	double sent;     //!< Number of items sent
+
+	Tx &operator+=(const Tx &other) {
+		received += other.received;
+		sent += other.sent;
+		return *this;
+	}
+
+	DECLARE_SERIALIZATION {
+		ar
+		& NAMED_OBJECT("recv", received)
+		& NAMED_OBJECT("sent", sent)
+		;
+	}
+};
+
+
+struct GroupStatistics : Core::BaseObject {
+	std::string name;
+	Tx          messages;
+	Tx          bytes;
+	Tx          payload;
+
+	DECLARE_SERIALIZATION {
+		ar
+		& NAMED_OBJECT("name", name)
+		& NAMED_OBJECT_HINT("messages", messages, Archive::STATIC_TYPE)
+		& NAMED_OBJECT_HINT("bytes", bytes, Archive::STATIC_TYPE)
+		& NAMED_OBJECT_HINT("payload", payload, Archive::STATIC_TYPE)
+		;
+	}
+};
+
+
+DEFINE_SMARTPOINTER(QueueStatistics);
+struct SC_BROKER_API QueueStatistics : Core::BaseObject {
+	typedef std::vector<GroupStatistics> Groups;
+	std::string name;
+	Groups      groups;
+	Tx          messages;
+	Tx          bytes;
+	Tx          payload;
+
+	QueueStatistics &operator+=(const QueueStatistics &stats);
+
+	DECLARE_SERIALIZATION {
+		ar
+		& NAMED_OBJECT("name", name)
+		& NAMED_OBJECT_HINT("messages", messages, Archive::STATIC_TYPE)
+		& NAMED_OBJECT_HINT("bytes", bytes, Archive::STATIC_TYPE)
+		& NAMED_OBJECT_HINT("payload", payload, Archive::STATIC_TYPE)
+		& NAMED_OBJECT_HINT("groups", groups, Archive::STATIC_TYPE)
+		;
+	}
+};
+
+
+
+}
+}
+}
+
+
+#endif

include/seiscomp/broker/utils/circular.h

@@ -0,0 +1,496 @@
+/******************************************************************************
+ * Author: Pete Goodliffe
+ *
+ * ----------------------------------------------------------------------------
+ * Copyright 2002 Pete Goodliffe All rights reserved.
+ *
+ * ----------------------------------------------------------------------------
+ * Purpose: STL-style circular buffer
+ *
+ * Formatting changed by <Jan Becker, gempa GmbH> jabe@gempa.de
+ *****************************************************************************/
+
+
+#ifndef CIRCULAR_BUFFER_H
+#define CIRCULAR_BUFFER_H
+
+
+#include <exception>
+#include <stdexcept>
+#include <iterator>
+#include <memory>
+
+
+/******************************************************************************
+ * Iterators
+ *****************************************************************************/
+
+/**
+ * Iterator type for the circular_buffer class.
+ *
+ * This one template class provides all variants of forward/reverse
+ * const/non const iterators through plentiful template magic.
+ *
+ * You don't need to instantiate it directly, use the good public functions
+ * availble in circular_buffer.
+ */
+template<typename T, //circular_buffer type
+                     //(incl const)
+        typename T_nonconst, //with any consts
+        typename elem_type = typename T::value_type> //+ const for const iter
+class circular_buffer_iterator {
+	public:
+		typedef circular_buffer_iterator<T, T_nonconst, elem_type> self_type;
+		typedef T cbuf_type;
+		typedef std::random_access_iterator_tag iterator_category;
+		typedef typename cbuf_type::value_type value_type;
+		typedef typename cbuf_type::size_type size_type;
+		typedef typename cbuf_type::pointer pointer;
+		typedef typename cbuf_type::const_pointer const_pointer;
+		typedef typename cbuf_type::reference reference;
+		typedef typename cbuf_type::const_reference const_reference;
+		typedef typename cbuf_type::difference_type difference_type;
+
+		circular_buffer_iterator(cbuf_type *b, size_type p)
+		: buf_(b), pos_(p) {}
+
+		// Converting a non-const iterator to a const iterator
+		circular_buffer_iterator(const circular_buffer_iterator<T_nonconst, T_nonconst, typename T_nonconst::value_type> &other)
+		: buf_(other.buf_), pos_(other.pos_) {}
+
+		friend class circular_buffer_iterator<const T, T, const elem_type> ;
+
+		// Use compiler generated copy ctor, copy assignment operator and dtor
+
+		elem_type &operator*() {
+			return (*buf_)[pos_];
+		}
+
+		elem_type *operator->() {
+			return &(operator*());
+		}
+
+		self_type &operator++() {
+			pos_ += 1;
+			return *this;
+		}
+
+		self_type operator++(int) {
+			self_type tmp(*this);
+			++(*this);
+			return tmp;
+		}
+
+		self_type &operator--() {
+			pos_ -= 1;
+			return *this;
+		}
+
+		self_type operator--(int) {
+			self_type tmp(*this);
+			--(*this);
+			return tmp;
+		}
+
+		self_type operator+(difference_type n) const {
+			self_type tmp(*this);
+			tmp.pos_ += n;
+			return tmp;
+		}
+
+		self_type &operator+=(difference_type n) {
+			pos_ += n;
+			return *this;
+		}
+
+		self_type operator-(difference_type n) const {
+			self_type tmp(*this);
+			tmp.pos_ -= n;
+			return tmp;
+		}
+
+		self_type &operator-=(difference_type n) {
+			pos_ -= n;
+			return *this;
+		}
+
+		difference_type operator-(const self_type &c) const {
+			return pos_ - c.pos_;
+		}
+
+		bool operator==(const self_type &other) const {
+			return pos_ == other.pos_ && buf_ == other.buf_;
+		}
+		bool operator!=(const self_type &other) const {
+			return pos_ != other.pos_ && buf_ == other.buf_;
+		}
+		bool operator>(const self_type &other) const {
+			return pos_ > other.pos_;
+		}
+		bool operator>=(const self_type &other) const {
+			return pos_ >= other.pos_;
+		}
+		bool operator<(const self_type &other) const {
+			return pos_ < other.pos_;
+		}
+		bool operator<=(const self_type &other) const {
+			return pos_ <= other.pos_;
+		}
+
+	private:
+		cbuf_type *buf_;
+		size_type pos_;
+};
+
+
+template<typename circular_buffer_iterator_t>
+circular_buffer_iterator_t operator+(
+	const typename circular_buffer_iterator_t::difference_type &a,
+	const circular_buffer_iterator_t &b) {
+	return circular_buffer_iterator_t(a) + b;
+}
+
+template<typename circular_buffer_iterator_t>
+circular_buffer_iterator_t operator-(
+	const typename circular_buffer_iterator_t::difference_type &a,
+	const circular_buffer_iterator_t &b) {
+	return circular_buffer_iterator_t(a) - b;
+}
+
+
+/******************************************************************************
+ * circular_buffer
+ *****************************************************************************/
+
+/**
+ * This class provides a circular buffer in the STL style.
+ *
+ * You can add data to the end using the @ref push_back function, read data
+ * using @ref front() and remove data using @ref pop_front().
+ *
+ * The class also provides random access through the @ref operator[]()
+ * function and its random access iterator. Subscripting the array with
+ * an invalid (out of range) index number leads to undefined results, both
+ * for reading and writing.
+ *
+ * This class template accepts three template parameters:
+ *   <li> T                            The type of object contained
+ *   <li> always_accept_data_when_full Determines the behaviour of
+ *                                     @ref push_back when the buffer is full.
+ *                                     Set to true new data is always added, the
+ *                                     old "end" data is thrown away.
+ *                                     Set to false, the new data is not added.
+ *                                     No error is returned neither is an
+ *                                     exception raised.
+ *   <li> Alloc                        Allocator type to use (in line with other
+ *                                     STL containers).
+ *
+ * @short   STL style circule buffer
+ * @author  Pete Goodliffe
+ * @version 1.00
+ */
+template<typename T, bool always_accept_data_when_full = true,
+         typename Alloc = std::allocator<T> >
+class circular_buffer {
+	public:
+		enum {
+			version_major = 1, version_minor = 0
+		};
+
+		// Typedefs
+		typedef circular_buffer<T, always_accept_data_when_full, Alloc> self_type;
+
+		typedef Alloc allocator_type;
+
+		typedef typename Alloc::value_type value_type;
+		typedef typename Alloc::pointer pointer;
+		typedef typename Alloc::const_pointer const_pointer;
+		typedef typename Alloc::reference reference;
+		typedef typename Alloc::const_reference const_reference;
+
+		typedef typename Alloc::size_type size_type;
+		typedef typename Alloc::difference_type difference_type;
+
+		typedef circular_buffer_iterator<self_type, self_type> iterator;
+		typedef circular_buffer_iterator<const self_type, self_type,
+		                                 const value_type> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		// Lifetime
+		enum {
+			default_capacity = 100
+		};
+
+		explicit circular_buffer(size_type capacity = default_capacity)
+		: array_(alloc_.allocate(capacity))
+		, array_size_(capacity)
+		, head_(1)
+		, tail_(0)
+		, contents_size_(0) {}
+
+		circular_buffer(const circular_buffer &other)
+		: array_(alloc_.allocate(other.array_size_))
+		, array_size_(other.array_size_), head_(other.head_)
+		, tail_(other.tail_), contents_size_(other.contents_size_) {
+			try {
+				assign_into(other.begin(), other.end());
+			}
+			catch ( ... ) {
+				destroy_all_elements();
+				alloc_.deallocate(array_, array_size_);
+				throw;
+			}
+		}
+
+		template<class InputIterator>
+		circular_buffer(InputIterator from, InputIterator to)
+		: array_(alloc_.allocate(1)), array_size_(1)
+		, head_(1), tail_(0), contents_size_(0) {
+			circular_buffer tmp;
+			tmp.assign_into_reserving(from, to);
+			swap(tmp);
+		}
+
+		~circular_buffer() {
+			destroy_all_elements();
+			alloc_.deallocate(array_, array_size_);
+		}
+
+		circular_buffer &operator=(const self_type &other) {
+			circular_buffer tmp(other);
+			swap(tmp);
+			return *this;
+		}
+
+		void swap(circular_buffer &other) {
+			std::swap(array_, other.array_);
+			std::swap(array_size_, other.array_size_);
+			std::swap(head_, other.head_);
+			std::swap(tail_, other.tail_);
+			std::swap(contents_size_, other.contents_size_);
+		}
+
+		allocator_type get_allocator() const {
+			return alloc_;
+		}
+
+		// Iterators
+		iterator begin() {
+			return iterator(this, 0);
+		}
+
+		iterator end() {
+			return iterator(this, size());
+		}
+
+		const_iterator begin() const {
+			return const_iterator(this, 0);
+		}
+
+		const_iterator end() const {
+			return const_iterator(this, size());
+		}
+
+		reverse_iterator rbegin() {
+			return reverse_iterator(end());
+		}
+
+		reverse_iterator rend() {
+			return reverse_iterator(begin());
+		}
+
+		const_reverse_iterator rbegin() const {
+			return const_reverse_iterator(end());
+		}
+
+		const_reverse_iterator rend() const {
+			return const_reverse_iterator(begin());
+		}
+
+		// Size
+		size_type size() const {
+			return contents_size_;
+		}
+
+		size_type capacity() const {
+			return array_size_;
+		}
+
+		bool empty() const {
+			return !contents_size_;
+		}
+
+		size_type max_size() const {
+			return alloc_.max_size();
+		}
+
+		void reserve(size_type new_size) {
+			if ( capacity() < new_size ) {
+				circular_buffer tmp(new_size);
+				tmp.assign_into(begin(), end());
+				swap(tmp);
+			}
+		}
+
+		// Accessing
+		reference front() {
+			return array_[head_];
+		}
+
+		reference back() {
+			return array_[tail_];
+		}
+
+		const_reference front() const {
+			return array_[head_];
+		}
+
+		const_reference back() const {
+			return array_[tail_];
+		}
+
+		void push_back(const value_type &item) {
+			size_type next = next_tail();
+			if ( contents_size_ == array_size_ ) {
+				if ( always_accept_data_when_full ) {
+					array_[next] = item;
+					increment_head();
+				}
+			}
+			else {
+				alloc_.construct(array_ + next, item);
+			}
+			increment_tail();
+		}
+
+		void pop_front() {
+			size_type destroy_pos = head_;
+			increment_head();
+			alloc_.destroy(array_ + destroy_pos);
+		}
+
+		void clear() {
+			for ( size_type n = 0; n < contents_size_; ++n ) {
+				alloc_.destroy(array_ + index_to_subscript(n));
+			}
+			head_ = 1;
+			tail_ = contents_size_ = 0;
+		}
+
+		reference operator[](size_type n) {
+			return at_unchecked(n);
+		}
+
+		const_reference operator[](size_type n) const {
+			return at_unchecked(n);
+		}
+
+		reference at(size_type n) {
+			return at_checked(n);
+		}
+
+		const_reference at(size_type n) const {
+			return at_checked(n);
+		}
+
+
+	private:
+		reference at_unchecked(size_type index) const {
+			return array_[index_to_subscript(index)];
+		}
+
+		reference at_checked(size_type index) const {
+			if ( index >= contents_size_ ) {
+				throw std::out_of_range("index out of bounds");
+			}
+			return at_unchecked(index);
+		}
+
+		// Rounds an unbounded to an index into array_
+		size_type normalise(size_type n) const {
+			return n % array_size_;
+		}
+
+		// Converts external index to an array subscript
+		size_type index_to_subscript(size_type index) const {
+			return normalise(index + head_);
+		}
+
+		void increment_tail() {
+			++contents_size_;
+			tail_ = next_tail();
+		}
+
+		size_type next_tail() {
+			return (tail_ + 1 == array_size_) ? 0 : tail_ + 1;
+		}
+
+		void increment_head() {
+			// precondition: !empty()
+			++head_;
+			--contents_size_;
+			if ( head_ == array_size_ )
+				head_ = 0;
+		}
+
+		template<typename f_iter>
+		void assign_into(f_iter from, f_iter to) {
+			if ( contents_size_ )
+				clear();
+			while ( from != to ) {
+				push_back(*from);
+				++from;
+			}
+		}
+
+		template<typename f_iter>
+		void assign_into_reserving(f_iter from, f_iter to) {
+			if ( contents_size_ )
+				clear();
+
+			while ( from != to ) {
+				if ( contents_size_ == array_size_ ) {
+					reserve(static_cast<size_type>(array_size_ * 1.5));
+				}
+
+				push_back(*from);
+				++from;
+			}
+		}
+
+		void destroy_all_elements() {
+			for ( size_type n = 0; n < contents_size_; ++n ) {
+				alloc_.destroy(array_ + index_to_subscript(n));
+			}
+		}
+
+		allocator_type alloc_;
+		value_type *array_;
+		size_type array_size_;
+		size_type head_;
+		size_type tail_;
+		size_type contents_size_;
+};
+
+
+template<typename T, bool consume_policy, typename Alloc>
+bool operator==(const circular_buffer<T, consume_policy, Alloc> &a,
+                const circular_buffer<T, consume_policy, Alloc> &b) {
+	return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
+}
+
+template<typename T, bool consume_policy, typename Alloc>
+bool operator!=(const circular_buffer<T, consume_policy, Alloc> &a,
+                const circular_buffer<T, consume_policy, Alloc> &b) {
+	return a.size() != b.size() || !std::equal(a.begin(), a.end(), b.begin());
+}
+
+template<typename T, bool consume_policy, typename Alloc>
+bool operator<(const circular_buffer<T, consume_policy, Alloc> &a,
+               const circular_buffer<T, consume_policy, Alloc> &b) {
+	return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+
+#endif

include/seiscomp/broker/utils/khash.h

@@ -0,0 +1,627 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+#include "khash.h"
+KHASH_MAP_INIT_INT(32, char)
+int main() {
+	int ret, is_missing;
+	khiter_t k;
+	khash_t(32) *h = kh_init(32);
+	k = kh_put(32, h, 5, &ret);
+	kh_value(h, k) = 10;
+	k = kh_get(32, h, 10);
+	is_missing = (k == kh_end(h));
+	k = kh_get(32, h, 5);
+	kh_del(32, h, k);
+	for (k = kh_begin(h); k != kh_end(h); ++k)
+		if (kh_exist(h, k)) kh_value(h, k) = 1;
+	kh_destroy(32, h);
+	return 0;
+}
+*/
+
+/*
+  2013-05-02 (0.2.8):
+
+	* Use quadratic probing. When the capacity is power of 2, stepping function
+	  i*(i+1)/2 guarantees to traverse each bucket. It is better than double
+	  hashing on cache performance and is more robust than linear probing.
+
+	  In theory, double hashing should be more robust than quadratic probing.
+	  However, my implementation is probably not for large hash tables, because
+	  the second hash function is closely tied to the first hash function,
+	  which reduce the effectiveness of double hashing.
+
+	Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php
+
+  2011-12-29 (0.2.7):
+
+    * Minor code clean up; no actual effect.
+
+  2011-09-16 (0.2.6):
+
+	* The capacity is a power of 2. This seems to dramatically improve the
+	  speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
+
+	   - http://code.google.com/p/ulib/
+	   - http://nothings.org/computer/judy/
+
+	* Allow to optionally use linear probing which usually has better
+	  performance for random input. Double hashing is still the default as it
+	  is more robust to certain non-random input.
+
+	* Added Wang's integer hash function (not used by default). This hash
+	  function is more robust to certain non-random input.
+
+  2011-02-14 (0.2.5):
+
+    * Allow to declare global functions.
+
+  2009-09-26 (0.2.4):
+
+    * Improve portability
+
+  2008-09-19 (0.2.3):
+
+	* Corrected the example
+	* Improved interfaces
+
+  2008-09-11 (0.2.2):
+
+	* Improved speed a little in kh_put()
+
+  2008-09-10 (0.2.1):
+
+	* Added kh_clear()
+	* Fixed a compiling error
+
+  2008-09-02 (0.2.0):
+
+	* Changed to token concatenation which increases flexibility.
+
+  2008-08-31 (0.1.2):
+
+	* Fixed a bug in kh_get(), which has not been tested previously.
+
+  2008-08-31 (0.1.1):
+
+	* Added destructor
+*/
+
+
+#ifndef __AC_KHASH_H
+#define __AC_KHASH_H
+
+/*!
+  @header
+
+  Generic hash table library.
+ */
+
+#define AC_VERSION_KHASH_H "0.2.8"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+/* compiler specific configuration */
+
+#if UINT_MAX == 0xffffffffu
+typedef unsigned int khint32_t;
+#elif ULONG_MAX == 0xffffffffu
+typedef unsigned long khint32_t;
+#endif
+
+#if ULONG_MAX == ULLONG_MAX
+typedef unsigned long khint64_t;
+#else
+typedef unsigned long long khint64_t;
+#endif
+
+#ifndef kh_inline
+#ifdef _MSC_VER
+#define kh_inline __inline
+#else
+#define kh_inline inline
+#endif
+#endif /* kh_inline */
+
+#ifndef klib_unused
+#if (defined __clang__ && __clang_major__ >= 3) || (defined __GNUC__ && __GNUC__ >= 3)
+#define klib_unused __attribute__ ((__unused__))
+#else
+#define klib_unused
+#endif
+#endif /* klib_unused */
+
+typedef khint32_t khint_t;
+typedef khint_t khiter_t;
+
+#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
+#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
+#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
+#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
+#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
+#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
+#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
+
+#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#ifndef kcalloc
+#define kcalloc(N,Z) calloc(N,Z)
+#endif
+#ifndef kmalloc
+#define kmalloc(Z) malloc(Z)
+#endif
+#ifndef krealloc
+#define krealloc(P,Z) realloc(P,Z)
+#endif
+#ifndef kfree
+#define kfree(P) free(P)
+#endif
+
+static const double __ac_HASH_UPPER = 0.77;
+
+#define __KHASH_TYPE(name, khkey_t, khval_t) \
+	typedef struct kh_##name##_s { \
+		khint_t n_buckets, size, n_occupied, upper_bound; \
+		khint32_t *flags; \
+		khkey_t *keys; \
+		khval_t *vals; \
+	} kh_##name##_t;
+
+#define __KHASH_PROTOTYPES(name, khkey_t, khval_t)	 					\
+	extern kh_##name##_t *kh_init_##name(void);							\
+	extern void kh_destroy_##name(kh_##name##_t *h);					\
+	extern void kh_clear_##name(kh_##name##_t *h);						\
+	extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); 	\
+	extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
+	extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
+	extern void kh_del_##name(kh_##name##_t *h, khint_t x);
+
+#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	SCOPE kh_##name##_t *kh_init_##name(void) {							\
+		return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t));		\
+	}																	\
+	SCOPE void kh_destroy_##name(kh_##name##_t *h)						\
+	{																	\
+		if (h) {														\
+			kfree((void *)h->keys); kfree(h->flags);					\
+			kfree((void *)h->vals);										\
+			kfree(h);													\
+		}																\
+	}																	\
+	SCOPE void kh_clear_##name(kh_##name##_t *h)						\
+	{																	\
+		if (h && h->flags) {											\
+			memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
+			h->size = h->n_occupied = 0;								\
+		}																\
+	}																	\
+	SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) 	\
+	{																	\
+		if (h->n_buckets) {												\
+			khint_t k, i, last, mask, step = 0; \
+			mask = h->n_buckets - 1;									\
+			k = __hash_func(key); i = k & mask;							\
+			last = i; \
+			while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+				i = (i + (++step)) & mask; \
+				if (i == last) return h->n_buckets;						\
+			}															\
+			return __ac_iseither(h->flags, i)? h->n_buckets : i;		\
+		} else return 0;												\
+	}																	\
+	SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
+	{ /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
+		khint32_t *new_flags = 0;										\
+		khint_t j = 1;													\
+		{																\
+			kroundup32(new_n_buckets); 									\
+			if (new_n_buckets < 4) new_n_buckets = 4;					\
+			if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0;	/* requested size is too small */ \
+			else { /* hash table size to be changed (shrink or expand); rehash */ \
+				new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t));	\
+				if (!new_flags) return -1;								\
+				memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
+				if (h->n_buckets < new_n_buckets) {	/* expand */		\
+					khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+					if (!new_keys) { kfree(new_flags); return -1; }		\
+					h->keys = new_keys;									\
+					if (kh_is_map) {									\
+						khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+						if (!new_vals) { kfree(new_flags); return -1; }	\
+						h->vals = new_vals;								\
+					}													\
+				} /* otherwise shrink */								\
+			}															\
+		}																\
+		if (j) { /* rehashing is needed */								\
+			for (j = 0; j != h->n_buckets; ++j) {						\
+				if (__ac_iseither(h->flags, j) == 0) {					\
+					khkey_t key = h->keys[j];							\
+					khval_t val;										\
+					khint_t new_mask;									\
+					new_mask = new_n_buckets - 1; 						\
+					if (kh_is_map) val = h->vals[j];					\
+					__ac_set_isdel_true(h->flags, j);					\
+					while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
+						khint_t k, i, step = 0; \
+						k = __hash_func(key);							\
+						i = k & new_mask;								\
+						while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
+						__ac_set_isempty_false(new_flags, i);			\
+						if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
+							{ khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \
+							if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \
+							__ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
+						} else { /* write the element and jump out of the loop */ \
+							h->keys[i] = key;							\
+							if (kh_is_map) h->vals[i] = val;			\
+							break;										\
+						}												\
+					}													\
+				}														\
+			}															\
+			if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
+				h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+				if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+			}															\
+			kfree(h->flags); /* free the working space */				\
+			h->flags = new_flags;										\
+			h->n_buckets = new_n_buckets;								\
+			h->n_occupied = h->size;									\
+			h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
+		}																\
+		return 0;														\
+	}																	\
+	SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \
+	{																	\
+		khint_t x;														\
+		if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \
+			if (h->n_buckets > (h->size<<1)) {							\
+				if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
+					*ret = -1; return h->n_buckets;						\
+				}														\
+			} else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
+				*ret = -1; return h->n_buckets;							\
+			}															\
+		} /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
+		{																\
+			khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
+			x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \
+			if (__ac_isempty(h->flags, i)) x = i; /* for speed up */	\
+			else {														\
+				last = i; \
+				while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+					if (__ac_isdel(h->flags, i)) site = i;				\
+					i = (i + (++step)) & mask; \
+					if (i == last) { x = site; break; }					\
+				}														\
+				if (x == h->n_buckets) {								\
+					if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \
+					else x = i;											\
+				}														\
+			}															\
+		}																\
+		if (__ac_isempty(h->flags, x)) { /* not present at all */		\
+			h->keys[x] = key;											\
+			__ac_set_isboth_false(h->flags, x);							\
+			++h->size; ++h->n_occupied;									\
+			*ret = 1;													\
+		} else if (__ac_isdel(h->flags, x)) { /* deleted */				\
+			h->keys[x] = key;											\
+			__ac_set_isboth_false(h->flags, x);							\
+			++h->size;													\
+			*ret = 2;													\
+		} else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
+		return x;														\
+	}																	\
+	SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x)				\
+	{																	\
+		if (x != h->n_buckets && !__ac_iseither(h->flags, x)) {			\
+			__ac_set_isdel_true(h->flags, x);							\
+			--h->size;													\
+		}																\
+	}
+
+#define KHASH_DECLARE(name, khkey_t, khval_t)		 					\
+	__KHASH_TYPE(name, khkey_t, khval_t) 								\
+	__KHASH_PROTOTYPES(name, khkey_t, khval_t)
+
+#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	__KHASH_TYPE(name, khkey_t, khval_t) 								\
+	__KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	KHASH_INIT2(name, static kh_inline klib_unused, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+/* --- BEGIN OF HASH FUNCTIONS --- */
+
+/*! @function
+  @abstract     Integer hash function
+  @param  key   The integer [khint32_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int_hash_func(key) (khint32_t)(key)
+/*! @function
+  @abstract     Integer comparison function
+ */
+#define kh_int_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     64-bit integer hash function
+  @param  key   The integer [khint64_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
+/*! @function
+  @abstract     64-bit integer comparison function
+ */
+#define kh_int64_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     const char* hash function
+  @param  s     Pointer to a null terminated string
+  @return       The hash value
+ */
+static kh_inline khint_t __ac_X31_hash_string(const char *s)
+{
+	khint_t h = (khint_t)*s;
+	if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s;
+	return h;
+}
+/*! @function
+  @abstract     Another interface to const char* hash function
+  @param  key   Pointer to a null terminated string [const char*]
+  @return       The hash value [khint_t]
+ */
+#define kh_str_hash_func(key) __ac_X31_hash_string(key)
+/*! @function
+  @abstract     Const char* comparison function
+ */
+#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
+
+static kh_inline khint_t __ac_Wang_hash(khint_t key)
+{
+    key += ~(key << 15);
+    key ^=  (key >> 10);
+    key +=  (key << 3);
+    key ^=  (key >> 6);
+    key += ~(key << 11);
+    key ^=  (key >> 16);
+    return key;
+}
+#define kh_int_hash_func2(k) __ac_Wang_hash((khint_t)key)
+
+/* --- END OF HASH FUNCTIONS --- */
+
+/* Other convenient macros... */
+
+/*!
+  @abstract Type of the hash table.
+  @param  name  Name of the hash table [symbol]
+ */
+#define khash_t(name) kh_##name##_t
+
+/*! @function
+  @abstract     Initiate a hash table.
+  @param  name  Name of the hash table [symbol]
+  @return       Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_init(name) kh_init_##name()
+
+/*! @function
+  @abstract     Destroy a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_destroy(name, h) kh_destroy_##name(h)
+
+/*! @function
+  @abstract     Reset a hash table without deallocating memory.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_clear(name, h) kh_clear_##name(h)
+
+/*! @function
+  @abstract     Resize a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  s     New size [khint_t]
+ */
+#define kh_resize(name, h, s) kh_resize_##name(h, s)
+
+/*! @function
+  @abstract     Insert a key to the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @param  r     Extra return code: -1 if the operation failed;
+                0 if the key is present in the hash table;
+                1 if the bucket is empty (never used); 2 if the element in
+				the bucket has been deleted [int*]
+  @return       Iterator to the inserted element [khint_t]
+ */
+#define kh_put(name, h, k, r) kh_put_##name(h, k, r)
+
+/*! @function
+  @abstract     Retrieve a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @return       Iterator to the found element, or kh_end(h) if the element is absent [khint_t]
+ */
+#define kh_get(name, h, k) kh_get_##name(h, k)
+
+/*! @function
+  @abstract     Remove a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Iterator to the element to be deleted [khint_t]
+ */
+#define kh_del(name, h, k) kh_del_##name(h, k)
+
+/*! @function
+  @abstract     Test whether a bucket contains data.
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       1 if containing data; 0 otherwise [int]
+ */
+#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x)))
+
+/*! @function
+  @abstract     Get key given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Key [type of keys]
+ */
+#define kh_key(h, x) ((h)->keys[x])
+
+/*! @function
+  @abstract     Get value given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Value [type of values]
+  @discussion   For hash sets, calling this results in segfault.
+ */
+#define kh_val(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Alias of kh_val()
+ */
+#define kh_value(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Get the start iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The start iterator [khint_t]
+ */
+#define kh_begin(h) (khint_t)(0)
+
+/*! @function
+  @abstract     Get the end iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The end iterator [khint_t]
+ */
+#define kh_end(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Get the number of elements in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of elements in the hash table [khint_t]
+ */
+#define kh_size(h) ((h)->size)
+
+/*! @function
+  @abstract     Get the number of buckets in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of buckets in the hash table [khint_t]
+ */
+#define kh_n_buckets(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Iterate over the entries in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  kvar  Variable to which key will be assigned
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach(h, kvar, vvar, code) { khint_t __i;		\
+	for (__i = kh_begin(h); __i != kh_end(h); ++__i) {		\
+		if (!kh_exist(h,__i)) continue;						\
+		(kvar) = kh_key(h,__i);								\
+		(vvar) = kh_val(h,__i);								\
+		code;												\
+	} }
+
+/*! @function
+  @abstract     Iterate over the values in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach_value(h, vvar, code) { khint_t __i;		\
+	for (__i = kh_begin(h); __i != kh_end(h); ++__i) {		\
+		if (!kh_exist(h,__i)) continue;						\
+		(vvar) = kh_val(h,__i);								\
+		code;												\
+	} }
+
+/* More conenient interfaces */
+
+/*! @function
+  @abstract     Instantiate a hash set containing integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT(name)										\
+	KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT(name, khval_t)								\
+	KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT64(name)										\
+	KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT64(name, khval_t)								\
+	KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
+
+typedef const char *kh_cstr_t;
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_STR(name)										\
+	KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_STR(name, khval_t)								\
+	KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
+
+#endif /* __AC_KHASH_H */

include/seiscomp/broker/utils/utils.h

@@ -0,0 +1,442 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * Author: Jan Becker                                                      *
+ * Email: jabe@gempa.de                                                    *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef GEMPA_MESSAGESERVER_UTILS_H__
+#define GEMPA_MESSAGESERVER_UTILS_H__
+
+
+#include <seiscomp/core/exceptions.h>
+#include <seiscomp/broker/api.h>
+
+#include <vector>
+#include <cstdio>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <type_traits>
+#include <boost/noncopyable.hpp>
+
+
+namespace Seiscomp {
+namespace Utils {
+
+
+/**
+ * @brief The Randomizer class generated random data of arbitrary length.
+ *
+ * This class utilized /dev/urandom under Unix. Other operating systems are
+ * not yet supported. Randomizer is implemented as a singleton. The usage
+ * is as simple as:
+ *
+ * \code
+ * if ( !Randomizer::Instance().fillData(data, len) )
+ *     cerr << "Failed to generate random data" << endl;
+ * \endcode
+ *
+ * A helper template method Randomizer::fill is provided which takes an
+ * argument of arbitrary type and fills it with random data.
+ *
+ * \code
+ * int id;
+ * if ( !Randomizer::Instance().fill(id) )
+ *     cerr << "Failed to generate id" << endl;
+ * \endcode
+ */
+class SC_BROKER_API Randomizer {
+	// ----------------------------------------------------------------------
+	//  Destruction
+	// ----------------------------------------------------------------------
+	public:
+		//! D'tor
+		~Randomizer();
+
+
+	// ----------------------------------------------------------------------
+	//  Public interface
+	// ----------------------------------------------------------------------
+	public:
+		/**
+		 * @brief Returns the singleton instance.
+		 * @return The singleton instance
+		 */
+		static Randomizer &Instance() { return _instance; }
+
+		/**
+		 * @brief Fills a value with random data.
+		 * @param target The value to be filled.
+		 * @return true on success, false otherwise
+		 */
+		template <typename T>
+		bool fill(T &target);
+
+		/**
+		 * @brief Fills a block of data with random data
+		 * @param data The pointer to the memory block
+		 * @param len The length in bytes of the memory block
+		 * @return true on success, false otherwise
+		 */
+		bool fillData(void *data, size_t len);
+
+
+	// ----------------------------------------------------------------------
+	//  Private interface
+	// ----------------------------------------------------------------------
+	private:
+		//! Private constructor
+		Randomizer();
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		static Randomizer _instance;
+		FILE *_randomFd;
+};
+
+
+template <typename T>
+bool Randomizer::fill(T &target) {
+	return fillData(&target, sizeof(target));
+}
+
+
+template <typename T>
+class BlockingDequeue : private boost::noncopyable {
+	// ----------------------------------------------------------------------
+	//  Public types
+	// ----------------------------------------------------------------------
+	public:
+		typedef std::unique_lock<std::mutex> lock;
+
+	// ----------------------------------------------------------------------
+	//  X'truction
+	// ----------------------------------------------------------------------
+	public:
+		BlockingDequeue();
+		BlockingDequeue(int n);
+		~BlockingDequeue();
+
+
+	// ----------------------------------------------------------------------
+	//  Blocking interface
+	// ----------------------------------------------------------------------
+	public:
+		void resize(int n);
+
+		bool canPush() const;
+		bool push(T v);
+
+		bool canPop() const;
+		T pop();
+
+		bool pop(T &);
+
+		void close();
+		void reopen();
+
+		size_t size() const;
+
+		void lockBuffer();
+		void unlockBuffer();
+
+		//! Requires lockBuffer to be called
+		size_t buffered() const;
+
+		//! Requires lockBuffer to be called
+		T &operator[](size_t idx);
+
+
+	// ----------------------------------------------------------------------
+	//  Private members
+	// ----------------------------------------------------------------------
+	private:
+		volatile int            _begin, _end;
+		volatile size_t         _buffered;
+		volatile bool           _closed;
+		std::vector<T>          _buffer;
+		std::condition_variable _notFull, _notEmpty;
+		mutable std::mutex      _monitor;
+};
+
+
+
+template <typename T, int IsPtr>
+struct BlockingDequeueHelper {};
+
+template <typename T>
+struct BlockingDequeueHelper<T,0> {
+	static void clean(const std::vector<T> &) {}
+	static T defaultValue() { return T(); }
+};
+
+template <typename T>
+struct BlockingDequeueHelper<T,1> {
+	static void clean(const std::vector<T> &b) {
+		for ( size_t i = 0; i < b.size(); ++i ) {
+			if ( b[i] ) delete b[i];
+		}
+	}
+
+	static T defaultValue() { return NULL; }
+};
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+BlockingDequeue<T>::BlockingDequeue() :
+	_begin(0), _end(0),
+	_buffered(0), _closed(false), _buffer(0)
+{}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+BlockingDequeue<T>::BlockingDequeue(int n) :
+	_begin(0), _end(0),
+	_buffered(0), _closed(false), _buffer(n)
+{}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+BlockingDequeue<T>::~BlockingDequeue() {
+	close();
+	BlockingDequeueHelper<T, std::is_pointer<T>::value>::clean(_buffer);
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+void BlockingDequeue<T>::resize(int n) {
+	lock lk(_monitor);
+	_buffer.resize(n);
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+bool BlockingDequeue<T>::canPush() const {
+	lock lk(_monitor);
+
+	if ( _closed )
+		throw Core::GeneralException("Queue has been closed");
+
+	return _buffered < _buffer.size();
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+bool BlockingDequeue<T>::push(T v) {
+	lock lk(_monitor);
+	while (_buffered == _buffer.size() && !_closed)
+		_notFull.wait(lk);
+	if ( _closed ) {
+		_notEmpty.notify_all();
+		return false;
+	}
+	_buffer[_end] = v;
+	_end = (_end+1) % _buffer.size();
+	++_buffered;
+	_notEmpty.notify_all();
+	return true;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+bool BlockingDequeue<T>::canPop() const {
+	lock lk(_monitor);
+
+	if ( _closed )
+		throw Core::GeneralException("Queue has been closed");
+
+	return _buffered > 0;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+T BlockingDequeue<T>::pop() {
+	lock lk(_monitor);
+	while (_buffered == 0 && !_closed) {
+		_notEmpty.wait(lk);
+	}
+	if ( _closed )
+		throw Core::GeneralException("Queue has been closed");
+	T v = _buffer[_begin];
+	_buffer[_begin] = BlockingDequeueHelper<T, std::is_pointer<T>::value>::defaultValue();
+	_begin = (_begin+1) % _buffer.size();
+	--_buffered;
+	_notFull.notify_all();
+	return v;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+bool BlockingDequeue<T>::pop(T &v) {
+	lock lk(_monitor);
+
+	if ( _closed )
+		throw Core::GeneralException("Queue has been closed");
+
+	if ( _buffered > 0 ) {
+		v = _buffer[_begin];
+		_buffer[_begin] = BlockingDequeueHelper<T, std::is_pointer<T>::value>::defaultValue();
+		_begin = (_begin+1) % _buffer.size();
+		--_buffered;
+		_notFull.notify_all();
+		return true;
+	}
+	else
+		return false;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+void BlockingDequeue<T>::close() {
+	lock lk(_monitor);
+	if ( _closed ) return;
+	_closed = true;
+	_notFull.notify_all();
+	_notEmpty.notify_all();
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+void BlockingDequeue<T>::reopen() {
+	lock lk(_monitor);
+	_closed = false;
+	if ( !_buffered )
+		_notFull.notify_all();
+	else
+		_notEmpty.notify_all();
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+size_t BlockingDequeue<T>::size() const {
+	lock lk(_monitor);
+	return _buffered;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+void BlockingDequeue<T>::lockBuffer() {
+	_monitor.lock();
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+void BlockingDequeue<T>::unlockBuffer() {
+	_monitor.unlock();
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+size_t BlockingDequeue<T>::buffered() const {
+	return _buffered;
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+template <typename T>
+T &BlockingDequeue<T>::operator[](size_t idx) {
+	idx += _begin;
+	if ( idx >= _buffer.size() )
+		idx -= _buffer.size();
+
+	return _buffer[idx];
+}
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+
+
+
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+}
+}
+
+
+#endif