x eagerly intersected with y.
TODO: move to container/common.d. TODO: Check that ElementType's of C1 and C2 match. Look at std.algorithm.intersection for hints.
exercise opEquals
import std.typecons : Nullable; import nxt.digestx.fnv : FNV; alias K = Nullable!(ulong, ulong.max); alias X = FlatHashSet!(K, FNV!(64, true)); const n = 100; X a; foreach (const i_; 0 .. n) { const i = 1113*i_; // insert in order assert(!a.contains(K(i))); assert(!a.containsUsingLinearSearch(K(i))); assert(a.insertAndReturnElement(K(i)) == K(i)); assert(a.contains(K(i))); assert(a.containsUsingLinearSearch(K(i))); } X b; foreach (const i_; 0 .. n) { const i = 1113*(n - 1 - i_); // insert in reverse assert(!b.contains(K(i))); assert(!b.containsUsingLinearSearch(K(i))); assert(b.insertAndReturnElement(K(i)) == K(i)); assert(b.contains(K(i))); assert(b.containsUsingLinearSearch(K(i))); } assert(a == b); // bin storage must be deterministic () @trusted { assert(a._store != b._store); }();
string as key
1 import nxt.container.traits : mustAddGCRange; 2 import nxt.digestx.fnv : FNV; 3 4 alias X = FlatHashSet!(string, FNV!(64, true)); 5 debug static assert(!mustAddGCRange!X); 6 debug static assert(X.sizeof == 24); // dynamic arrays also `hasAddressLikeKey` 7 8 auto x = X(); 9 10 auto testEscapeShouldFail()() @safe pure 11 { 12 X x; 13 x.insert("a"); 14 return x.byElement; 15 } 16 17 auto testEscapeShouldFailFront()() @safe pure 18 { 19 X x; 20 x.insert("a"); 21 return x.byElement.front; 22 } 23 24 assert(&"a"[0] is &"a"[0]); // string literals are store in common place 25 26 const aa = "aa"; 27 28 // string slices are equal when elements are equal regardless of position 29 // (.ptr) in memory 30 assert(x.insertAndReturnElement(aa[0 .. 1]) !is "a"); 31 x.insert(aa[0 .. 1]); 32 assert(x.insertAndReturnElement(aa[0 .. 1]) is aa[0 .. 1]); 33 assert(x.contains(aa[1 .. 2])); 34 assert(x.containsUsingLinearSearch(aa[1 .. 2])); 35 36 const(char)[] aa_ = "aa"; 37 assert(x.contains(aa_[1 .. 2])); 38 assert(x.containsUsingLinearSearch(aa_[1 .. 2])); 39 assert(aa_[1 .. 2] in x); 40 41 char[2] aa__; aa__ = "aa"; 42 assert(x.contains(aa__[1 .. 2])); 43 assert(x.containsUsingLinearSearch(aa__[1 .. 2])); 44 assert(aa__[1 .. 2] in x); 45 46 const bb = "bb"; 47 48 assert(x.insertAndReturnElement(bb[0 .. 1]) is bb[0 .. 1]); // returns newly added ref 49 assert(x.insertAndReturnElement(bb[0 .. 1]) !is "b"); // return other ref not equal new literal 50 x.insert(bb[0 .. 1]); 51 assert(x.contains(bb[1 .. 2])); 52 assert(x.containsUsingLinearSearch(bb[1 .. 2])); 53 54 x.remove(aa[0 .. 1]); 55 assert(!x.contains(aa[1 .. 2])); 56 assert(!x.containsUsingLinearSearch(aa[1 .. 2])); 57 assert(x.contains(bb[1 .. 2])); 58 assert(x.containsUsingLinearSearch(bb[1 .. 2])); 59 60 x.remove(bb[0 .. 1]); 61 assert(!x.contains(bb[1 .. 2])); 62 assert(!x.containsUsingLinearSearch(bb[1 .. 2])); 63 64 x.insert("a"); 65 x.insert("b"); 66 assert(x.contains("a")); 67 assert(x.containsUsingLinearSearch("a")); 68 assert(x.contains("b")); 69 assert(x.containsUsingLinearSearch("b")); 70 71 debug static assert(!__traits(compiles, { testEscapeShouldFail(); } )); 72 // TODO: this should fail: 73 // TODO: debug static assert(!__traits(compiles, { testEscapeShouldFailFront(); } ));
string as key
import nxt.digestx.fnv : FNV; alias X = FlatHashSet!(string, FNV!(64, true)); auto x = X(); char[2] cc = "cc"; // mutable chars assert(x.insertAndReturnElement(cc[]) !is cc[]); // will allocate new slice const cc_ = "cc"; // immutable chars assert(x.insertAndReturnElement(cc_[]) !is cc[]); // will not allocate
array container as value type
1 import std.meta : AliasSeq; 2 import std.typecons : Nullable; 3 import nxt.container.traits : mustAddGCRange; 4 import nxt.digestx.fnv : FNV; 5 import nxt.array_help : s; 6 7 alias K = Nullable!(uint, uint.max); 8 9 alias VE = Nullable!(uint, uint.max); 10 alias V = FlatHashSet!(VE, FNV!(64, true)); 11 12 debug static assert(!mustAddGCRange!V); 13 14 foreach (X; AliasSeq!(FlatHashMap!(K, V, FNV!(64, true)))) 15 { 16 const VE n = 600; 17 18 auto x = X(); 19 20 { // scoped range 21 auto xkeys = x.byKey; 22 assert(xkeys.length == 0); 23 foreach (ref key; xkeys) 24 { 25 debug static assert(is(typeof(key) == const(K))); 26 assert(0); 27 } 28 foreach (ref key; X().byKey) 29 { 30 debug static assert(is(typeof(key) == const(K))); 31 assert(0); 32 } 33 } 34 35 foreach (immutable i; 0 .. n) 36 { 37 assert(x.length == i); 38 39 auto key = K(i); 40 auto value = V.withElements([VE(i)].s); 41 42 x[key] = value.dup; 43 assert(x.length == i + 1); 44 assert(x.contains(key)); 45 // TODO: assert(x.containsUsingLinearSearch(key)); 46 { 47 auto valuePtr = key in x; 48 assert(valuePtr && *valuePtr == value); 49 } 50 51 x.remove(key); 52 assert(x.length == i); 53 assert(!x.contains(key)); 54 assert(key !in x); 55 56 x[key] = value.dup; 57 assert(x.length == i + 1); 58 assert(x.contains(key)); 59 { 60 auto valuePtr = key in x; 61 assert(valuePtr && *valuePtr == value); 62 } 63 } 64 65 assert(x is x); 66 67 x = x.dup; 68 69 auto y = x.dup; 70 assert(x !is y); 71 assert(x.length == y.length); 72 73 assert(y == x); 74 assert(x == y); 75 76 foreach (ref key; x.byKey) 77 { 78 assert(x.contains(key)); 79 } 80 81 foreach (ref keyValue; x.byKeyValue) 82 { 83 assert(x.contains(keyValue.key)); 84 auto keyValuePtr = keyValue.key in x; 85 assert(keyValuePtr && 86 *keyValuePtr == keyValue.value); 87 } 88 89 foreach (immutable i; 0 .. n) 90 { 91 assert(x.length == n - i); 92 93 auto key = K(i); 94 auto value = V.withElements([VE(i)].s); 95 96 assert(x.contains(key)); 97 { 98 auto valuePtr = key in x; 99 assert(valuePtr && *valuePtr == value); 100 } 101 102 x.remove(key); 103 assert(!x.contains(key)); 104 assert(key !in x); 105 } 106 107 auto z = y.dup; 108 assert(y == z); 109 110 /* remove all elements in `y` using `removeAllMatching` and all elements 111 * in `z` using `removeAllMatching` */ 112 foreach (immutable i; 0 .. n) 113 { 114 assert(y.length == n - i); 115 assert(z.length == n - i); 116 117 auto key = K(i); 118 auto value = V.withElements([VE(i)].s); 119 120 assert(y.contains(key)); 121 { 122 auto valuePtr = key in y; 123 assert(valuePtr && *valuePtr == value); 124 } 125 assert(z.contains(key)); 126 { 127 auto valuePtr = key in z; 128 assert(valuePtr && *valuePtr == value); 129 } 130 131 y.remove(key); 132 assert(z.removeAllMatching!((const scope ref element) => element.key is key) == 1); 133 assert(y == z); 134 135 assert(!y.contains(key)); 136 assert(!z.contains(key)); 137 138 assert(key !in y); 139 assert(key !in z); 140 } 141 }
r-value and l-value intersection
import core.lifetime : move; import std.typecons : Nullable; import nxt.digestx.fnv : FNV; import nxt.array_help : s; alias K = Nullable!(uint, uint.max); alias X = FlatHashSet!(K, FNV!(64, true)); auto x = X(); { // scoped range foreach (ref _; x.byElement) { assert(0); } } auto x0 = X.init; assert(x0.length == 0); assert(x0._store.length == 0); assert(!x0.contains(K(1))); auto x1 = X.withElements([K(12)].s); assert(x1.length == 1); assert(x1.contains(K(12))); auto x2 = X.withElements([K(10), K(12)].s); assert(x2.length == 2); assert(x2.contains(K(10))); assert(x2.contains(K(12))); auto x3 = X.withElements([K(12), K(13), K(14)].s); assert(x3.length == 3); assert(x3.contains(K(12))); assert(x3.contains(K(13))); assert(x3.contains(K(14))); auto z = X.withElements([K(10), K(12), K(13), K(15)].s); assert(z.length == 4); assert(z.contains(K(10))); assert(z.contains(K(12))); assert(z.contains(K(13))); assert(z.contains(K(15))); auto y = move(z).intersectedWith(x2); assert(y.length == 2); assert(y.contains(K(10))); assert(y.contains(K(12))); assert(y.containsUsingLinearSearch(K(10))); assert(y.containsUsingLinearSearch(K(12)));
r-value and r-value intersection
import std.typecons : Nullable; import nxt.digestx.fnv : FNV; import nxt.array_help : s; alias K = Nullable!(uint, uint.max); alias X = FlatHashSet!(K, FNV!(64, true)); auto y = X.withElements([K(10), K(12), K(13), K(15)].s).intersectedWith(X.withElements([K(12), K(13)].s)); assert(y.length == 2); assert(y.contains(K(12))); assert(y.contains(K(13))); assert(y.containsUsingLinearSearch(K(12))); assert(y.containsUsingLinearSearch(K(13)));