Major plugin refactor and cleanup.

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

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

@@ -0,0 +1,369 @@
+//
+// HashTable.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashTable
+//
+// Definition of the HashTable class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashTable_INCLUDED
+#define Foundation_HashTable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/HashFunction.h"
+#include "Poco/HashStatistic.h"
+#include <vector>
+#include <map>
+#include <cstddef>
+#include <cstring>
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class Key, class Value, class KeyHashFunction = HashFunction<Key>>
+class HashTable
+	/// A HashTable stores a key value pair that can be looked up via a hashed key.
+	///
+	/// Collision handling is done via overflow maps(!). With small hash tables performance of this
+	/// data struct will be closer to that a map than a hash table, i.e. slower. On the plus side,
+	/// this class offers remove operations. Also HashTable full errors are not possible. If a fast
+	/// HashTable implementation is needed and the remove operation is not required, use SimpleHashTable
+	/// instead.
+	///
+	/// This class is NOT thread safe.
+{
+public:
+	typedef std::map<Key, Value> HashEntryMap;
+	typedef HashEntryMap**       HashTableVector;
+
+	typedef typename HashEntryMap::const_iterator ConstIterator;
+	typedef typename HashEntryMap::iterator Iterator;
+
+	HashTable(UInt32 initialSize = 251): 
+		_entries(0), 
+		_size(0), 
+		_maxCapacity(initialSize)
+		/// Creates the HashTable.
+	{
+		_entries = new HashEntryMap*[initialSize];
+		memset(_entries, '\0', sizeof(HashEntryMap*)*initialSize);
+	}
+
+	HashTable(const HashTable& ht):
+		_entries(new HashEntryMap*[ht._maxCapacity]),
+		_size(ht._size),
+		_maxCapacity(ht._maxCapacity)
+	{
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			if (ht._entries[i])
+				_entries[i] = new HashEntryMap(ht._entries[i]->begin(), ht._entries[i]->end());
+			else
+				_entries[i] = 0;
+		}
+	}
+
+	~HashTable()
+		/// Destroys the HashTable.
+	{
+		clear();
+	}
+
+	HashTable& operator = (const HashTable& ht)
+	{
+		if (this != &ht)
+		{
+			clear();
+			_maxCapacity = ht._maxCapacity;
+			poco_assert_dbg (_entries == 0);
+			_entries = new HashEntryMap*[_maxCapacity];
+			_size = ht._size;
+
+			for (UInt32 i = 0; i < _maxCapacity; ++i)
+			{
+				if (ht._entries[i])
+					_entries[i] = new HashEntryMap(ht._entries[i]->begin(), ht._entries[i]->end());
+				else
+					_entries[i] = 0;
+			}
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		if (!_entries)
+			return;
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			delete _entries[i];
+		}
+		delete[] _entries;
+		_entries     = 0;
+		_size        = 0;
+		_maxCapacity = 0;
+	}
+
+	UInt32 insert(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		UInt32 hsh = hash(key);
+		insertRaw(key, hsh, value);
+		return hsh;
+	}
+
+	Value& insertRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		if (!_entries[hsh])
+			_entries[hsh] = new HashEntryMap();
+		std::pair<typename HashEntryMap::iterator, bool> res(_entries[hsh]->insert(std::make_pair(key, value)));
+		if (!res.second)
+			throw InvalidArgumentException("HashTable::insert, key already exists.");
+		_size++;
+		return res.first->second;
+	}
+
+	UInt32 update(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		UInt32 hsh = hash(key);
+		updateRaw(key, hsh, value);
+		return hsh;
+	}
+
+	void updateRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		if (!_entries[hsh])
+			_entries[hsh] = new HashEntryMap();
+		std::pair<Iterator, bool> res = _entries[hsh]->insert(std::make_pair(key, value));
+		if (res.second == false)
+			res.first->second = value;
+		else
+			_size++;
+	}
+
+	void remove(const Key& key)
+	{
+		UInt32 hsh = hash(key);
+		removeRaw(key, hsh);
+	}
+
+	void removeRaw(const Key& key, UInt32 hsh)
+		/// Performance version, allows to specify the hash value
+	{
+		if (_entries[hsh])
+		{
+			_size -= _entries[hsh]->erase(key);
+		}
+	}
+
+	UInt32 hash(const Key& key) const
+	{
+		return _hash(key, _maxCapacity);
+	}
+
+	const Value& get(const Key& key) const
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh);
+	}
+
+	const Value& getRaw(const Key& key, UInt32 hsh) const
+		/// Throws an exception if the value does not exist
+	{
+		if (!_entries[hsh])
+			throw InvalidArgumentException("key not found");
+
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			throw InvalidArgumentException("key not found");
+
+		return it->second;
+	}
+
+	Value& get(const Key& key)
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return const_cast<Value&>(getRaw(key, hsh));
+	}
+
+	const Value& operator [] (const Key& key) const
+	{
+		return get(key);
+	}
+	
+	Value& operator [] (const Key& key)
+	{
+		UInt32 hsh = hash(key);
+
+		if (!_entries[hsh])
+			return insertRaw(key, hsh, Value());
+			
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			return insertRaw(key, hsh, Value());
+
+		return it->second;
+	}
+	
+	const Key& getKeyRaw(const Key& key, UInt32 hsh)
+		/// Throws an exception if the key does not exist. returns a reference to the internally
+		/// stored key. Useful when someone does an insert and wants for performance reason only to store
+		/// a pointer to the key in another collection
+	{
+		if (!_entries[hsh])
+			throw InvalidArgumentException("key not found");
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			throw InvalidArgumentException("key not found");
+		return it->first;
+	}
+
+	bool get(const Key& key, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh, v);
+	}
+
+	bool getRaw(const Key& key, UInt32 hsh, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		if (!_entries[hsh])
+			return false;
+
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			return false;
+
+		v = it->second;
+		return true;
+	}
+
+	bool exists(const Key& key)
+	{
+		UInt32 hsh = hash(key);
+		return existsRaw(key, hsh);
+	}
+
+	bool existsRaw(const Key& key, UInt32 hsh)
+	{
+		return _entries[hsh] && (_entries[hsh]->end() != _entries[hsh]->find(key));
+	}
+
+	std::size_t size() const
+		/// Returns the number of elements already inserted into the HashTable
+	{
+		return _size;
+	}
+	
+	UInt32 maxCapacity() const
+	{
+		return _maxCapacity;
+	}
+
+	void resize(UInt32 newSize)
+		/// Resizes the hashtable, rehashes all existing entries. Expensive!
+	{
+		if (_maxCapacity != newSize)
+		{
+			HashTableVector cpy = _entries;
+			_entries = 0;
+			UInt32 oldSize = _maxCapacity;
+			_maxCapacity = newSize;
+			_entries = new HashEntryMap*[_maxCapacity];
+			memset(_entries, '\0', sizeof(HashEntryMap*)*_maxCapacity);
+
+			if (_size == 0)
+			{
+				// no data was yet inserted
+				delete[] cpy;
+				return;
+			}
+			_size = 0;
+			for (UInt32 i = 0; i < oldSize; ++i)
+			{
+				if (cpy[i])
+				{
+					ConstIterator it = cpy[i]->begin();
+					ConstIterator itEnd = cpy[i]->end();
+					for (; it != itEnd; ++it)
+					{
+						insert(it->first, it->second);
+					}
+					delete cpy[i];
+				}
+			}
+			delete[] cpy;
+		}
+	}
+
+	HashStatistic currentState(bool details = false) const
+		/// Returns the current internal state
+	{
+		UInt32 numberOfEntries = (UInt32)_size;
+		UInt32 numZeroEntries = 0;
+		UInt32 maxEntriesPerHash = 0;
+		std::vector<UInt32> detailedEntriesPerHash;
+	#ifdef _DEBUG
+		UInt32 totalSize = 0;
+	#endif
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			if (_entries[i])
+			{
+				UInt32 size = (UInt32)_entries[i]->size();
+				poco_assert_dbg(size != 0);
+				if (size > maxEntriesPerHash)
+					maxEntriesPerHash = size;
+				if (details)
+					detailedEntriesPerHash.push_back(size);
+	#ifdef _DEBUG
+				totalSize += size;
+	#endif
+			}
+			else
+			{
+				numZeroEntries++;
+				if (details)
+					detailedEntriesPerHash.push_back(0);
+			}
+		}
+	#ifdef _DEBUG
+		poco_assert_dbg(totalSize == numberOfEntries);
+	#endif
+		return HashStatistic(_maxCapacity, numberOfEntries, numZeroEntries, maxEntriesPerHash, detailedEntriesPerHash);
+	}
+
+private:
+	HashTableVector _entries;
+	std::size_t     _size;
+	UInt32          _maxCapacity;
+	KeyHashFunction _hash;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashTable_INCLUDED