range that iterates through the key-value-pairs of c in undefined order.
make range from l-value and r-value. element access is always const
1 import core.exception : AssertError; 2 import std.typecons : Nullable; 3 import nxt.digestx.fnv : FNV; 4 import nxt.array_help : s; 5 debug import std.exception : assertThrown; 6 7 import std.algorithm.searching : count; 8 alias K = Nullable!(uint, uint.max); 9 alias X = FlatHashSet!(K, 10 FNV!(64, true), 11 defaultKeyEqualPredOf!K, 12 Mallocator, 13 true); 14 15 auto k11 = K(11); 16 auto k22 = K(22); 17 auto k33 = K(33); 18 auto ks = [k11, k22, k33].s; 19 auto k44 = K(44); 20 21 // mutable 22 auto x = X.withElements(ks); 23 assert(!x.contains(k44)); 24 assert(!x.containsUsingLinearSearch(k44)); 25 assert(x.length == 3); 26 27 assert(x.byElement.count == x.length); 28 foreach (e; x.byElement) // from l-value 29 { 30 debug static assert(is(typeof(e) == const(K))); // always const access 31 32 // range invalidation forbidden: 33 debug 34 { 35 assertThrown!AssertError(x.reserveExtra(1)); // range invalidation 36 assertThrown!AssertError(x.clear()); // range invalidation 37 assertThrown!AssertError(x.insert(k11)); // range invalidation 38 assertThrown!AssertError(x.insertN([k11].s)); // range invalidation 39 assertThrown!AssertError(x.remove(k11)); // range invalidation 40 } 41 42 // allowed 43 assert(x.contains(e)); 44 assert(x.containsUsingLinearSearch(e)); 45 46 const eHit = e in x; 47 assert(eHit); // found 48 assert(*eHit is e); // and the value equals what we searched for 49 50 const eDup = x.dup; // duplication is `const` and allowed 51 assert(eDup == x); 52 } 53 54 // const 55 const y = X.withElements(ks); 56 assert(!x.contains(k44)); 57 assert(!x.containsUsingLinearSearch(k44)); 58 foreach (e; y.byElement) // from l-value 59 { 60 auto _ = y.byElement; // ok to read-borrow again 61 assert(y.contains(e)); 62 assert(y.containsUsingLinearSearch(e)); 63 debug static assert(is(typeof(e) == const(K))); 64 } 65 66 foreach (e; X.withElements([K(11)].s).byElement) // from r-value 67 { 68 assert(e == K(11)); 69 debug static assert(is(typeof(e) == const(K))); // always const access 70 }
range checking
import core.exception : RangeError; import std.typecons : Nullable; import nxt.digestx.fnv : FNV; debug import std.exception : assertThrown, assertNotThrown; immutable n = 11; alias K = Nullable!(uint, uint.max); alias V = uint; alias X = FlatHashMap!(K, V, FNV!(64, true)); auto s = X.withCapacity(n); void dummy(ref V value) {} debug assertThrown!RangeError(dummy(s[K(0)])); foreach (immutable i; 0 .. n) { const k = K(i); s[k] = V(i); debug assertNotThrown!RangeError(dummy(s[k])); } foreach (immutable i; 0 .. n) { const k = K(i); assert(s.remove(k)); debug assertThrown!RangeError(dummy(s[k])); } s[K(0)] = V.init; auto vp = K(0) in s; debug static assert(is(typeof(vp) == V*)); assert((*vp) == V.init); assert(s.remove(K(0))); assert(K(0) !in s); X t; t.reserveExtra(4096); t.clear();
class as value
1 import core.exception : RangeError; 2 import std.typecons : Nullable; 3 debug import std.exception : assertThrown, assertNotThrown; 4 import nxt.digestx.fnv : FNV; 5 6 immutable n = 11; 7 8 alias K = Nullable!(uint, uint.max); 9 class V 10 { 11 this(uint data) { this.data = data; } 12 uint data; 13 } 14 15 alias X = FlatHashMap!(K, V, FNV!(64, true)); 16 17 auto s = X.withCapacity(n); 18 19 void dummy(ref V value) {} 20 21 debug assertThrown!RangeError(dummy(s[K(0)])); 22 23 foreach (immutable i; 0 .. n) 24 { 25 const k = K(i); 26 s[k] = new V(i); 27 debug assertNotThrown!RangeError(dummy(s[k])); 28 } 29 30 // test range 31 { 32 auto sr = s.byKeyValue; // scoped range 33 assert(sr.length == n); 34 foreach (immutable i; 0 .. n) 35 { 36 sr.popFront(); 37 assert(sr.length == n - i - 1); 38 } 39 } 40 41 foreach (immutable i; 0 .. n) 42 { 43 const k = K(i); 44 assert(s.remove(k)); 45 debug assertThrown!RangeError(dummy(s[k])); 46 } 47 48 s[K(0)] = V.init; 49 auto vp = K(0) in s; 50 debug static assert(is(typeof(vp) == V*)); 51 52 assert(s.remove(K(0))); 53 assert(K(0) !in s); 54 55 X t; 56 t.reserveExtra(4096);
constness inference of ranges
import std.typecons : Nullable; import nxt.digestx.fnv : FNV; alias K = Nullable!(uint, uint.max); class V { this(uint data) { this.data = data; } uint data; } alias X = FlatHashMap!(K, V, FNV!(64, true)); const x = X(); foreach (const e; x.byKey) { debug static assert(is(typeof(e) == const(X.KeyType))); } foreach (const e; x.byValue) { debug static assert(is(typeof(e) == const(X.ValueType))); } foreach (const e; X.init.byValue) { debug static assert(is(typeof(e) == const(X.ValueType))); } foreach (const e; x.byKeyValue) { debug static assert(is(typeof(e.key) == const(X.KeyType))); debug static assert(is(typeof(e.value) == const(X.ValueType))); debug static assert(is(typeof(e) == const(X.ElementType))); }
range key constness and value mutability with class value
import std.typecons : Nullable; import nxt.digestx.fnv : FNV; struct S { uint value; } alias K = Nullable!(S, S(uint.min)); // use uint.min to trigger use of faster `allocator.allocateZeroed` class V { this(uint data) { this.data = data; } uint data; } alias X = FlatHashMap!(K, V, FNV!(64, true)); auto x = X(); x[K(S(42))] = new V(43); assert(x.length == 1); foreach (e; x.byValue) // `e` is auto ref { debug static assert(is(typeof(e) == X.ValueType)); // mutable access to value assert(e.data == 43); // value mutation side effects e.data += 1; assert(e.data == 44); e.data -= 1; assert(e.data == 43); } foreach (ref e; x.byKeyValue) // `e` is auto ref { debug static assert(is(typeof(e.key) == const(X.KeyType))); // const access to key debug static assert(is(typeof(e.value) == X.ValueType)); // mutable access to value assert(e.key.value == 42); assert(e.value.data == 43); // key cannot be mutated debug static assert(!__traits(compiles, { e.key.value += 1; })); // value mutation side effects e.value.data += 1; assert(e.value.data == 44); e.value.data -= 1; assert(e.value.data == 43); }
range key constness and value mutability with class key and class value
1 import nxt.digestx.fnv : FNV; 2 3 class K 4 { 5 this(uint value) 6 { 7 this.value = value; 8 } 9 10 @property bool opEquals(const scope typeof(this) rhs) const 11 { 12 return value == rhs.value; 13 } 14 15 uint value; 16 } 17 18 class V 19 { 20 this(uint data) { this.data = data; } 21 uint data; 22 } 23 24 alias X = FlatHashMap!(K, V, FNV!(64, true)); 25 auto x = X(); 26 27 x[new K(42)] = new V(43); 28 29 assert(x.length == 1); 30 31 foreach (e; x.byValue) // `e` is auto ref 32 { 33 debug static assert(is(typeof(e) == X.ValueType)); // mutable access to value 34 assert(e.data == 43); 35 36 // value mutation side effects 37 e.data += 1; 38 assert(e.data == 44); 39 e.data -= 1; 40 assert(e.data == 43); 41 } 42 43 foreach (ref e; x.byKeyValue) // `e` is auto ref 44 { 45 debug static assert(is(typeof(e.key) == X.KeyType)); // mutable access to class key 46 debug static assert(is(typeof(e.value) == X.ValueType)); // mutable access to value 47 48 assert(e.key.value == 42); 49 assert(e.value.data == 43); 50 51 // class key itself should not be mutable 52 debug static assert(!__traits(compiles, { e.key = null; })); 53 54 // members of key can be mutated 55 debug static assert(__traits(compiles, { e.key.value += 1; })); 56 57 // value mutation side effects 58 e.value.data += 1; 59 assert(e.value.data == 44); 60 e.value.data -= 1; 61 assert(e.value.data == 43); 62 }
range key constness and value mutability with class key and class value
1 import nxt.digestx.fnv : FNV; 2 class K 3 { 4 this(uint value) 5 { 6 this.value = value; 7 } 8 uint value; 9 } 10 11 struct V 12 { 13 this(uint data) { this.data = data; } 14 @disable this(this); 15 uint data; 16 } 17 18 alias X = FlatHashMap!(K, V, FNV!(64, true)); 19 auto x = X(); 20 21 scope key42 = new K(42); 22 x[key42] = V(43); 23 24 assert(x.length == 1); 25 26 foreach (ref e; x.byValue) // `e` is auto ref 27 { 28 debug static assert(is(typeof(e) == X.ValueType)); // mutable access to value 29 assert(e.data == 43); 30 31 // value mutation side effects 32 e.data += 1; 33 assert(e.data == 44); 34 e.data -= 1; 35 assert(e.data == 43); 36 } 37 38 foreach (ref e; x.byKeyValue) // `e` is auto ref 39 { 40 debug static assert(is(typeof(e.key) == X.KeyType)); // mutable access to class key 41 debug static assert(is(typeof(e.value) == X.ValueType)); // mutable access to value 42 43 assert(e.key.value == 42); 44 assert(e.value.data == 43); 45 46 // value mutation side effects 47 e.value.data += 1; 48 assert(e.value.data == 44); 49 e.value.data -= 1; 50 assert(e.value.data == 43); 51 } 52 53 assert(x.length == 1); 54 55 assert(x.remove(key42)); 56 assert(x.length == 0); 57 58 x[key42] = V(43); 59 assert(x.length == 1);