Add byKey, byValue/opSlice, and byKeyValue to HashMap (#103)

Add byKey, byValue/opSlice, and byKeyValue to HashMap
merged-on-behalf-of: Jonathan Crapuchettes <jcrapuchettes@users.noreply.github.com>

Author: Hackerpilot

dub.json

@@ -8,6 +8,6 @@
         "DLang Community"
     ],
     "dependencies": {
-		"stdx-allocator": "~>2.77.0"
+        "stdx-allocator": "~>2.77.0"
     }
 }

src/containers/hashmap.d

@@ -10,7 +10,7 @@ module containers.hashmap;
 private import containers.internal.hash : generateHash;
 private import containers.internal.node : shouldAddGCRange;
 private import stdx.allocator.mallocator : Mallocator;
-private import std.traits : isBasicType;
+private import std.traits : isBasicType, Unqual;
 
 /**
  * Associative array / hash map.
@@ -37,7 +37,7 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		/**
 		 * Use the given `allocator` for allocations.
 		 */
-		this(Allocator allocator)
+		this(Allocator allocator) pure nothrow @nogc @safe
 		in
 		{
 			assert(allocator !is null, "Allocator must not be null");
@@ -85,12 +85,24 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		}
 	}
 
-	~this()
+	~this() nothrow
+	{
+		scope (failure) assert(false);
+		clear();
+	}
+
+	/**
+	 * Removes all items from the map
+	 */
+	void clear()
 	{
 		import stdx.allocator : dispose;
+
 		static if (useGC)
 			GC.removeRange(buckets.ptr);
 		allocator.dispose(buckets);
+		buckets = null;
+		_length = 0;
 	}
 
 	/**
@@ -206,7 +218,7 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 	/**
 	 * Supports $(B aa[key] = value;) syntax.
 	 */
-	void opIndexAssign(V value, K key)
+	void opIndexAssign(V value, const K key)
 	{
 		insert(key, value);
 	}
@@ -217,7 +229,7 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 	 * Returns: pointer to the value corresponding to the given key,
 	 * or null if the key is not present in the HashMap.
 	 */
-	inout(V)* opBinaryRight(string op)(K key) inout nothrow if (op == "in")
+	inout(V)* opBinaryRight(string op)(K key) inout nothrow @trusted if (op == "in")
 	{
 		if (_length == 0)
 			return null;
@@ -274,6 +286,14 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		return _length == 0;
 	}
 
+	/**
+	 * Returns: a range of the keys in this map.
+	 */
+	auto byKey(this This)() inout @trusted
+	{
+		return Slice!(This, IterType.key)(cast(Unqual!(This)*) &this);
+	}
+
 	/**
 	 * Returns: a GC-allocated array filled with the keys contained in this map.
 	 */
@@ -294,6 +314,16 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		return app.data;
 	}
 
+
+	/**
+	 * Returns: a range of the values in this map.
+	 */
+	auto byValue(this This)() inout @trusted
+	{
+		return Slice!(This, IterType.value)(cast(Unqual!(This)*) &this);
+	}
+	alias opSlice = byValue;
+
 	/**
 	 * Returns: a GC-allocated array containing the values contained in this map.
 	 */
@@ -309,20 +339,29 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		foreach (ref const bucket; buckets)
 		{
 			foreach (item; bucket.range)
-				app.put(item.value);
+				app.put(cast(ContainerElementType!(This, V)) item.value);
 		}
 		return app.data;
 	}
 
+	/**
+	 * Returns: a range of the kev/value pairs in this map. The element type of
+	 *     this range is a struct with `key` and `value` fields.
+	 */
+	auto byKeyValue(this This)() inout @trusted
+	{
+		return Slice!(This, IterType.both)(cast(Unqual!(This)*) &this);
+	}
+
 	/**
 	 * Support for $(D foreach(key, value; aa) { ... }) syntax;
 	 */
-	int opApply(D)(D del) if(isOpApplyDelegate!(D, const(K), V))
+	int opApply(D)(D del) //if(isOpApplyDelegate!(D, const(K), V))
 	{
 		int result = 0;
 		foreach (ref bucket; buckets)
 		{
-			foreach (ref node; bucket.range)
+			foreach (ref node; bucket[])
 			{
 				result = del(node.key, node.value);
 				if (result != 0)
@@ -338,7 +377,7 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 		int result = 0;
 		foreach (const ref bucket; buckets)
 		{
-			foreach (const ref node; bucket.range)
+			foreach (const ref node; bucket[])
 			{
 				result = del(node.key, node.value);
 				if (result != 0)
@@ -350,7 +389,7 @@ struct HashMap(K, V, Allocator = Mallocator, alias hashFunction = generateHash!K
 
 private:
 
-	import stdx.allocator : make;
+	import stdx.allocator : make, makeArray;
 	import containers.unrolledlist : UnrolledList;
 	import containers.internal.storage_type : ContainerStorageType;
 	import containers.internal.element_type : ContainerElementType;
@@ -360,6 +399,93 @@ private:
 	enum bool useGC = supportGC && (shouldAddGCRange!K || shouldAddGCRange!V);
 	alias Hash = typeof({ K k = void; return hashFunction(k); }());
 
+	enum IterType: ubyte
+	{
+		key, value, both
+	}
+
+	static struct Slice(MapType, IterType Type)
+	{
+		static if (Type == IterType.both)
+		{
+			struct FrontType
+			{
+				ContainerElementType!(MapType, K) key;
+				ContainerElementType!(MapType, V) value;
+			}
+		}
+		else static if (Type == IterType.value)
+			alias FrontType = ContainerElementType!(MapType, V);
+		else static if (Type == IterType.key)
+			alias FrontType = ContainerElementType!(MapType, K);
+		else
+			static assert(false);
+
+		Unqual!(MapType)* hm;
+		size_t bucketIndex;
+		typeof(hm.buckets[0].opSlice()) bucketRange;
+		bool _empty;
+
+		this(Unqual!(MapType)* hm)
+		{
+			this.hm = hm;
+			this.bucketIndex = 0;
+			bucketRange = typeof(bucketRange).init;
+			this._empty = false;
+
+			while (true)
+			{
+				if (bucketIndex >= hm.buckets.length)
+				{
+					_empty = true;
+					break;
+				}
+				bucketRange = hm.buckets[bucketIndex][];
+				if (bucketRange.empty)
+					bucketIndex++;
+				else
+					break;
+			}
+		}
+
+		FrontType front()
+		{
+			static if (Type == IterType.both)
+				return FrontType(cast(ContainerElementType!(MapType, K)) bucketRange.front.key,
+					cast(ContainerElementType!(MapType, V)) bucketRange.front.value);
+			else static if (Type == IterType.value)
+				return cast(ContainerElementType!(MapType, V)) bucketRange.front.value;
+			else static if (Type == IterType.key)
+				return cast(ContainerElementType!(MapType, K)) bucketRange.front.key;
+			else
+				static assert(false);
+		}
+
+		bool empty() const pure nothrow @nogc @property
+		{
+			return _empty;
+		}
+
+		void popFront() pure nothrow @nogc
+		{
+			bucketRange.popFront();
+			if (bucketRange.empty)
+			{
+				while (bucketRange.empty)
+				{
+					bucketIndex++;
+					if (bucketIndex >= hm.buckets.length)
+					{
+						_empty = true;
+						break;
+					}
+					else
+						bucketRange = hm.buckets[bucketIndex][];
+				}
+			}
+		}
+	}
+
 	template isOpApplyDelegate(D, KT, VT)
 	{
 		import std.traits : isDelegate, isImplicitlyConvertible, isIntegral, Parameters, ReturnType;
@@ -374,8 +500,9 @@ private:
 	void initialize(size_t bucketCount = 4)
 	{
 		import std.conv : emplace;
+		assert((bucketCount & (bucketCount - 1)) == 0, "bucketCount must be a power of two");
 
-		buckets = (cast(Bucket*) allocator.allocate(bucketCount * Bucket.sizeof))[0 .. bucketCount];
+		buckets = makeArray!Bucket(allocator, bucketCount);
 		static if (useGC)
 			GC.addRange(buckets.ptr, buckets.length * Bucket.sizeof);
 		foreach (ref bucket; buckets)
@@ -387,7 +514,7 @@ private:
 		}
 	}
 
-	Node* insert(K key, V value)
+	Node* insert(const K key, V value)
 	{
 		if (buckets.length == 0)
 			initialize();
@@ -436,7 +563,6 @@ private:
 	 */
 	void rehash() @trusted
 	{
-//		import stdx.allocator : make, dispose;
 		import std.conv : emplace;
 		immutable size_t newLength = buckets.length << 1;
 		immutable size_t newSize = newLength * Bucket.sizeof;
@@ -533,6 +659,8 @@ private:
 unittest
 {
 	import std.uuid : randomUUID;
+	import std.algorithm.iteration : walkLength;
+
 	auto hm = HashMap!(string, int)(16);
 	assert (hm.length == 0);
 	assert (!hm.remove("abc"));
@@ -554,6 +682,12 @@ unittest
 	assert (hm.length == 1001);
 	assert (hm.keys().length == hm.length);
 	assert (hm.values().length == hm.length);
+	() @nogc {
+		assert (hm.byKey().walkLength == hm.length);
+		assert (hm.byValue().walkLength == hm.length);
+		assert (hm[].walkLength == hm.length);
+		assert (hm.byKeyValue().walkLength == hm.length);
+	}();
 	foreach (const ref string k, ref int v; hm) {}
 
 	auto hm2 = HashMap!(char, char)(4);

src/containers/internal/hash.d

@@ -6,10 +6,29 @@
  */
 module containers.internal.hash;
 
-hash_t generateHash(T)(T value) nothrow @trusted
+static if (hash_t.sizeof == 4)
 {
-	import std.functional : unaryFun;
-	hash_t h = typeid(T).getHash(&value);
-	h ^= (h >>> 20) ^ (h >>> 12);
-	return h ^ (h >>> 7) ^ (h >>> 4);
+	hash_t generateHash(T)(T value) nothrow @trusted
+	{
+		return typeid(T).getHash(&value);
+	}
+}
+else
+{
+	hash_t generateHash(T)(T value) nothrow @trusted if (!is(T == string))
+	{
+		return typeid(T).getHash(&value);
+	}
+
+	hash_t generateHash(T)(T value) pure nothrow @nogc @trusted if (is(T == string))
+	{
+		immutable ulong fullIterCount = value.length >>> 3;
+		immutable ulong remainderStart = fullIterCount << 3;
+		ulong h;
+		foreach (c; (cast(ulong*) value.ptr)[0 .. fullIterCount])
+			h = (h ^ c) ^ (h >>> 4);
+		foreach (c; value[remainderStart .. $])
+			h += (h << 7) + c;
+		return h;
+	}
 }

src/containers/openhashset.d

@@ -85,7 +85,7 @@ struct OpenHashSet(T, Allocator = Mallocator,
 		}
 	}
 
-	~this()
+	~this() nothrow
 	{
 		static if (useGC)
 			GC.removeRange(nodes.ptr);

src/containers/ttree.d

@@ -399,7 +399,8 @@ private:
 
 	// If we're storing a struct that defines opCmp, don't compare pointers as
 	// that is almost certainly not what the user intended.
-	static if (is(typeof(less) == string ) && less == "a < b" && isPointer!T && __traits(hasMember, PointerTarget!T, "opCmp"))
+	static if (is(typeof(less) == string ) && less == "a < b"
+			&& isPointer!T && __traits(hasMember, PointerTarget!T, "opCmp"))
 		alias _less = binaryFun!"a.opCmp(*b) < 0";
 	else
 		alias _less = binaryFun!less;
@@ -532,7 +533,7 @@ private:
 		bool insert(T value, ref Node* root, AllocatorType allocator)
 		in
 		{
-			static if (isPointer!T || is (T == class) || is (T == interface)) 
+			static if (isPointer!T || is (T == class) || is (T == interface))
 				assert (value !is null);
 		}
 		body