Showing the changes to gcc/libphobos/src/std/algorithm/mutation.d (1 of 31387 files). Show all
Unified · Split
| @@ -0,0 +1,2909 @@ | |||
| 1 | // Written in the D programming language. | ||
| 2 | /** | ||
| 3 | This is a submodule of $(MREF std, algorithm). | ||
| 4 | It contains generic _mutation algorithms. | ||
| 5 | |||
| 6 | $(SCRIPT inhibitQuickIndex = 1;) | ||
| 7 | $(BOOKTABLE Cheat Sheet, | ||
| 8 | $(TR $(TH Function Name) $(TH Description)) | ||
| 9 | $(T2 bringToFront, | ||
| 10 | If $(D a = [1, 2, 3]) and $(D b = [4, 5, 6, 7]), | ||
| 11 | $(D bringToFront(a, b)) leaves $(D a = [4, 5, 6]) and | ||
| 12 | $(D b = [7, 1, 2, 3]).) | ||
| 13 | $(T2 copy, | ||
| 14 | Copies a range to another. If | ||
| 15 | $(D a = [1, 2, 3]) and $(D b = new int[5]), then $(D copy(a, b)) | ||
| 16 | leaves $(D b = [1, 2, 3, 0, 0]) and returns $(D b[3 .. $]).) | ||
| 17 | $(T2 fill, | ||
| 18 | Fills a range with a pattern, | ||
| 19 | e.g., if $(D a = new int[3]), then $(D fill(a, 4)) | ||
| 20 | leaves $(D a = [4, 4, 4]) and $(D fill(a, [3, 4])) leaves | ||
| 21 | $(D a = [3, 4, 3]).) | ||
| 22 | $(T2 initializeAll, | ||
| 23 | If $(D a = [1.2, 3.4]), then $(D initializeAll(a)) leaves | ||
| 24 | $(D a = [double.init, double.init]).) | ||
| 25 | $(T2 move, | ||
| 26 | $(D move(a, b)) moves $(D a) into $(D b). $(D move(a)) reads $(D a) | ||
| 27 | destructively when necessary.) | ||
| 28 | $(T2 moveEmplace, | ||
| 29 | Similar to $(D move) but assumes `target` is uninitialized.) | ||
| 30 | $(T2 moveAll, | ||
| 31 | Moves all elements from one range to another.) | ||
| 32 | $(T2 moveEmplaceAll, | ||
| 33 | Similar to $(D moveAll) but assumes all elements in `target` are uninitialized.) | ||
| 34 | $(T2 moveSome, | ||
| 35 | Moves as many elements as possible from one range to another.) | ||
| 36 | $(T2 moveEmplaceSome, | ||
| 37 | Similar to $(D moveSome) but assumes all elements in `target` are uninitialized.) | ||
| 38 | $(T2 remove, | ||
| 39 | Removes elements from a range in-place, and returns the shortened | ||
| 40 | range.) | ||
| 41 | $(T2 reverse, | ||
| 42 | If $(D a = [1, 2, 3]), $(D reverse(a)) changes it to $(D [3, 2, 1]).) | ||
| 43 | $(T2 strip, | ||
| 44 | Strips all leading and trailing elements equal to a value, or that | ||
| 45 | satisfy a predicate. | ||
| 46 | If $(D a = [1, 1, 0, 1, 1]), then $(D strip(a, 1)) and | ||
| 47 | $(D strip!(e => e == 1)(a)) returns $(D [0]).) | ||
| 48 | $(T2 stripLeft, | ||
| 49 | Strips all leading elements equal to a value, or that satisfy a | ||
| 50 | predicate. If $(D a = [1, 1, 0, 1, 1]), then $(D stripLeft(a, 1)) and | ||
| 51 | $(D stripLeft!(e => e == 1)(a)) returns $(D [0, 1, 1]).) | ||
| 52 | $(T2 stripRight, | ||
| 53 | Strips all trailing elements equal to a value, or that satisfy a | ||
| 54 | predicate. | ||
| 55 | If $(D a = [1, 1, 0, 1, 1]), then $(D stripRight(a, 1)) and | ||
| 56 | $(D stripRight!(e => e == 1)(a)) returns $(D [1, 1, 0]).) | ||
| 57 | $(T2 swap, | ||
| 58 | Swaps two values.) | ||
| 59 | $(T2 swapAt, | ||
| 60 | Swaps two values by indices.) | ||
| 61 | $(T2 swapRanges, | ||
| 62 | Swaps all elements of two ranges.) | ||
| 63 | $(T2 uninitializedFill, | ||
| 64 | Fills a range (assumed uninitialized) with a value.) | ||
| 65 | ) | ||
| 66 | |||
| 67 | Copyright: Andrei Alexandrescu 2008-. | ||
| 68 | |||
| 69 | License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0). | ||
| 70 | |||
| 71 | Authors: $(HTTP erdani.com, Andrei Alexandrescu) | ||
| 72 | |||
| 73 | Source: $(PHOBOSSRC std/algorithm/_mutation.d) | ||
| 74 | |||
| 75 | Macros: | ||
| 76 | T2=$(TR $(TDNW $(LREF $1)) $(TD $+)) | ||
| 77 | */ | ||
| 78 | module std.algorithm.mutation; | ||
| 79 | |||
| 80 | import std.range.primitives; | ||
| 81 | import std.traits : isArray, isBlitAssignable, isNarrowString, Unqual, isSomeChar; | ||
| 82 | // FIXME | ||
| 83 | import std.typecons; // : tuple, Tuple; | ||
| 84 | |||
| 85 | // bringToFront | ||
| 86 | /** | ||
| 87 | The $(D bringToFront) function has considerable flexibility and | ||
| 88 | usefulness. It can rotate elements in one buffer left or right, swap | ||
| 89 | buffers of equal length, and even move elements across disjoint | ||
| 90 | buffers of different types and different lengths. | ||
| 91 | |||
| 92 | $(D bringToFront) takes two ranges $(D front) and $(D back), which may | ||
| 93 | be of different types. Considering the concatenation of $(D front) and | ||
| 94 | $(D back) one unified range, $(D bringToFront) rotates that unified | ||
| 95 | range such that all elements in $(D back) are brought to the beginning | ||
| 96 | of the unified range. The relative ordering of elements in $(D front) | ||
| 97 | and $(D back), respectively, remains unchanged. | ||
| 98 | |||
| 99 | The $(D bringToFront) function treats strings at the code unit | ||
| 100 | level and it is not concerned with Unicode character integrity. | ||
| 101 | $(D bringToFront) is designed as a function for moving elements | ||
| 102 | in ranges, not as a string function. | ||
| 103 | |||
| 104 | Performs $(BIGOH max(front.length, back.length)) evaluations of $(D | ||
| 105 | swap). | ||
| 106 | |||
| 107 | Preconditions: | ||
| 108 | |||
| 109 | Either $(D front) and $(D back) are disjoint, or $(D back) is | ||
| 110 | reachable from $(D front) and $(D front) is not reachable from $(D | ||
| 111 | back). | ||
| 112 | |||
| 113 | Params: | ||
| 114 | front = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives) | ||
| 115 | back = a $(REF_ALTTEXT forward range, isForwardRange, std,range,primitives) | ||
| 116 | |||
| 117 | Returns: | ||
| 118 | The number of elements brought to the front, i.e., the length of $(D back). | ||
| 119 | |||
| 120 | See_Also: | ||
| 121 | $(HTTP sgi.com/tech/stl/_rotate.html, STL's rotate) | ||
| 122 | */ | ||
| 123 | size_t bringToFront(InputRange, ForwardRange)(InputRange front, ForwardRange back) | ||
| 124 | if (isInputRange!InputRange && isForwardRange!ForwardRange) | ||
| 125 | { | ||
| 126 | import std.string : representation; | ||
| 127 | |||
| 128 | static if (isNarrowString!InputRange) | ||
| 129 | { | ||
| 130 | auto frontW = representation(front); | ||
| 131 | } | ||
| 132 | else | ||
| 133 | { | ||
| 134 | alias frontW = front; | ||
| 135 | } | ||
| 136 | static if (isNarrowString!ForwardRange) | ||
| 137 | { | ||
| 138 | auto backW = representation(back); | ||
| 139 | } | ||
| 140 | else | ||
| 141 | { | ||
| 142 | alias backW = back; | ||
| 143 | } | ||
| 144 | |||
| 145 | return bringToFrontImpl(frontW, backW); | ||
| 146 | } | ||
| 147 | |||
| 148 | private size_t bringToFrontImpl(InputRange, ForwardRange)(InputRange front, ForwardRange back) | ||
| 149 | if (isInputRange!InputRange && isForwardRange!ForwardRange) | ||
| 150 | { | ||
| 151 | import std.array : sameHead; | ||
| 152 | import std.range : take, Take; | ||
| 153 | enum bool sameHeadExists = is(typeof(front.sameHead(back))); | ||
| 154 | size_t result; | ||
| 155 | |||
| 156 | for (bool semidone; !front.empty && !back.empty; ) | ||
| 157 | { | ||
| 158 | static if (sameHeadExists) | ||
| 159 | { | ||
| 160 | if (front.sameHead(back)) break; // shortcut | ||
| 161 | } | ||
| 162 | // Swap elements until front and/or back ends. | ||
| 163 | auto back0 = back.save; | ||
| 164 | size_t nswaps; | ||
| 165 | do | ||
| 166 | { | ||
| 167 | static if (sameHeadExists) | ||
| 168 | { | ||
| 169 | // Detect the stepping-over condition. | ||
| 170 | if (front.sameHead(back0)) back0 = back.save; | ||
| 171 | } | ||
| 172 | swapFront(front, back); | ||
| 173 | ++nswaps; | ||
| 174 | front.popFront(); | ||
| 175 | back.popFront(); | ||
| 176 | } | ||
| 177 | while (!front.empty && !back.empty); | ||
| 178 | |||
| 179 | if (!semidone) result += nswaps; | ||
| 180 | |||
| 181 | // Now deal with the remaining elements. | ||
| 182 | if (back.empty) | ||
| 183 | { | ||
| 184 | if (front.empty) break; | ||
| 185 | // Right side was shorter, which means that we've brought | ||
| 186 | // all the back elements to the front. | ||
| 187 | semidone = true; | ||
| 188 | // Next pass: bringToFront(front, back0) to adjust the rest. | ||
| 189 | back = back0; | ||
| 190 | } | ||
| 191 | else | ||
| 192 | { | ||
| 193 | assert(front.empty); | ||
| 194 | // Left side was shorter. Let's step into the back. | ||
| 195 | static if (is(InputRange == Take!ForwardRange)) | ||
| 196 | { | ||
| 197 | front = take(back0, nswaps); | ||
| 198 | } | ||
| 199 | else | ||
| 200 | { | ||
| 201 | immutable subresult = bringToFront(take(back0, nswaps), | ||
| 202 | back); | ||
| 203 | if (!semidone) result += subresult; | ||
| 204 | break; // done | ||
| 205 | } | ||
| 206 | } | ||
| 207 | } | ||
| 208 | return result; | ||
| 209 | } | ||
| 210 | |||
| 211 | /** | ||
| 212 | The simplest use of $(D bringToFront) is for rotating elements in a | ||
| 213 | buffer. For example: | ||
| 214 | */ | ||
| 215 | @safe unittest | ||
| 216 | { | ||
| 217 | auto arr = [4, 5, 6, 7, 1, 2, 3]; | ||
| 218 | auto p = bringToFront(arr[0 .. 4], arr[4 .. $]); | ||
| 219 | assert(p == arr.length - 4); | ||
| 220 | assert(arr == [ 1, 2, 3, 4, 5, 6, 7 ]); | ||
| 221 | } | ||
| 222 | |||
| 223 | /** | ||
| 224 | The $(D front) range may actually "step over" the $(D back) | ||
| 225 | range. This is very useful with forward ranges that cannot compute | ||
| 226 | comfortably right-bounded subranges like $(D arr[0 .. 4]) above. In | ||
| 227 | the example below, $(D r2) is a right subrange of $(D r1). | ||
| 228 | */ | ||
| 229 | @safe unittest | ||
| 230 | { | ||
| 231 | import std.algorithm.comparison : equal; | ||
| 232 | import std.container : SList; | ||
| 233 | import std.range.primitives : popFrontN; | ||
| 234 | |||
| 235 | auto list = SList!(int)(4, 5, 6, 7, 1, 2, 3); | ||
| 236 | auto r1 = list[]; | ||
| 237 | auto r2 = list[]; popFrontN(r2, 4); | ||
| 238 | assert(equal(r2, [ 1, 2, 3 ])); | ||
| 239 | bringToFront(r1, r2); | ||
| 240 | assert(equal(list[], [ 1, 2, 3, 4, 5, 6, 7 ])); | ||
| 241 | } | ||
| 242 | |||
| 243 | /** | ||
| 244 | Elements can be swapped across ranges of different types: | ||
| 245 | */ | ||
| 246 | @safe unittest | ||
| 247 | { | ||
| 248 | import std.algorithm.comparison : equal; | ||
| 249 | import std.container : SList; | ||
| 250 | |||
| 251 | auto list = SList!(int)(4, 5, 6, 7); | ||
| 252 | auto vec = [ 1, 2, 3 ]; | ||
| 253 | bringToFront(list[], vec); | ||
| 254 | assert(equal(list[], [ 1, 2, 3, 4 ])); | ||
| 255 | assert(equal(vec, [ 5, 6, 7 ])); | ||
| 256 | } | ||
| 257 | |||
| 258 | /** | ||
| 259 | Unicode integrity is not preserved: | ||
| 260 | */ | ||
| 261 | @safe unittest | ||
| 262 | { | ||
| 263 | import std.string : representation; | ||
| 264 | auto ar = representation("a".dup); | ||
| 265 | auto br = representation("ç".dup); | ||
| 266 | |||
| 267 | bringToFront(ar, br); | ||
| 268 | |||
| 269 | auto a = cast(char[]) ar; | ||
| 270 | auto b = cast(char[]) br; | ||
| 271 | |||
| 272 | // Illegal UTF-8 | ||
| 273 | assert(a == "\303"); | ||
| 274 | // Illegal UTF-8 | ||
| 275 | assert(b == "\247a"); | ||
| 276 | } | ||
| 277 | |||
| 278 | @safe unittest | ||
| 279 | { | ||
| 280 | import std.algorithm.comparison : equal; | ||
| 281 | import std.conv : text; | ||
| 282 | import std.random : Random, unpredictableSeed, uniform; | ||
| 283 | |||
| 284 | // a more elaborate test | ||
| 285 | { | ||
| 286 | auto rnd = Random(unpredictableSeed); | ||
| 287 | int[] a = new int[uniform(100, 200, rnd)]; | ||
| 288 | int[] b = new int[uniform(100, 200, rnd)]; | ||
| 289 | foreach (ref e; a) e = uniform(-100, 100, rnd); | ||
| 290 | foreach (ref e; b) e = uniform(-100, 100, rnd); | ||
| 291 | int[] c = a ~ b; | ||
| 292 | // writeln("a= ", a); | ||
| 293 | // writeln("b= ", b); | ||
| 294 | auto n = bringToFront(c[0 .. a.length], c[a.length .. $]); | ||
| 295 | //writeln("c= ", c); | ||
| 296 | assert(n == b.length); | ||
| 297 | assert(c == b ~ a, text(c, "\n", a, "\n", b)); | ||
| 298 | } | ||
| 299 | // different types, moveFront, no sameHead | ||
| 300 | { | ||
| 301 | static struct R(T) | ||
| 302 | { | ||
| 303 | T[] data; | ||
| 304 | size_t i; | ||
| 305 | @property | ||
| 306 | { | ||
| 307 | R save() { return this; } | ||
| 308 | bool empty() { return i >= data.length; } | ||
| 309 | T front() { return data[i]; } | ||
| 310 | T front(real e) { return data[i] = cast(T) e; } | ||
| 311 | } | ||
| 312 | void popFront() { ++i; } | ||
| 313 | } | ||
| 314 | auto a = R!int([1, 2, 3, 4, 5]); | ||
| 315 | auto b = R!real([6, 7, 8, 9]); | ||
| 316 | auto n = bringToFront(a, b); | ||
| 317 | assert(n == 4); | ||
| 318 | assert(a.data == [6, 7, 8, 9, 1]); | ||
| 319 | assert(b.data == [2, 3, 4, 5]); | ||
| 320 | } | ||
| 321 | // front steps over back | ||
| 322 | { | ||
| 323 | int[] arr, r1, r2; | ||
| 324 | |||
| 325 | // back is shorter | ||
| 326 | arr = [4, 5, 6, 7, 1, 2, 3]; | ||
| 327 | r1 = arr; | ||
| 328 | r2 = arr[4 .. $]; | ||
| 329 | bringToFront(r1, r2) == 3 || assert(0); | ||
| 330 | assert(equal(arr, [1, 2, 3, 4, 5, 6, 7])); | ||
| 331 | |||
| 332 | // front is shorter | ||
| 333 | arr = [5, 6, 7, 1, 2, 3, 4]; | ||
| 334 | r1 = arr; | ||
| 335 | r2 = arr[3 .. $]; | ||
| 336 | bringToFront(r1, r2) == 4 || assert(0); | ||
| 337 | assert(equal(arr, [1, 2, 3, 4, 5, 6, 7])); | ||
| 338 | } | ||
| 339 | |||
| 340 | // Bugzilla 16959 | ||
| 341 | auto arr = ['4', '5', '6', '7', '1', '2', '3']; | ||
| 342 | auto p = bringToFront(arr[0 .. 4], arr[4 .. $]); | ||
| 343 | |||
| 344 | assert(p == arr.length - 4); | ||
| 345 | assert(arr == ['1', '2', '3', '4', '5', '6', '7']); | ||
| 346 | } | ||
| 347 | |||
| 348 | // Tests if types are arrays and support slice assign. | ||
| 349 | private enum bool areCopyCompatibleArrays(T1, T2) = | ||
| 350 | isArray!T1 && isArray!T2 && is(typeof(T2.init[] = T1.init[])); | ||
| 351 | |||
| 352 | // copy | ||
| 353 | /** | ||
| 354 | Copies the content of $(D source) into $(D target) and returns the | ||
| 355 | remaining (unfilled) part of $(D target). | ||
| 356 | |||
| 357 | Preconditions: $(D target) shall have enough room to accommodate | ||
| 358 | the entirety of $(D source). | ||
| 359 | |||
| 360 | Params: | ||
| 361 | source = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives) | ||
| 362 | target = an output range | ||
| 363 | |||
| 364 | Returns: | ||
| 365 | The unfilled part of target | ||
| 366 | |||
| 367 | See_Also: | ||
| 368 | $(HTTP sgi.com/tech/stl/_copy.html, STL's _copy) | ||
| 369 | */ | ||
| 370 | TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target) | ||
| 371 | if (areCopyCompatibleArrays!(SourceRange, TargetRange)) | ||
| 372 | { | ||
| 373 | const tlen = target.length; | ||
| 374 | const slen = source.length; | ||
| 375 | assert(tlen >= slen, | ||
| 376 | "Cannot copy a source range into a smaller target range."); | ||
| 377 | |||
| 378 | immutable overlaps = __ctfe || () @trusted { | ||
| 379 | return source.ptr < target.ptr + tlen && | ||
| 380 | target.ptr < source.ptr + slen; }(); | ||
| 381 | |||
| 382 | if (overlaps) | ||
| 383 | { | ||
| 384 | foreach (idx; 0 .. slen) | ||
| 385 | target[idx] = source[idx]; | ||
| 386 | return target[slen .. tlen]; | ||
| 387 | } | ||
| 388 | else | ||
| 389 | { | ||
| 390 | // Array specialization. This uses optimized memory copying | ||
| 391 | // routines under the hood and is about 10-20x faster than the | ||
| 392 | // generic implementation. | ||
| 393 | target[0 .. slen] = source[]; | ||
| 394 | return target[slen .. $]; | ||
| 395 | } | ||
| 396 | } | ||
| 397 | |||
| 398 | /// ditto | ||
| 399 | TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target) | ||
| 400 | if (!areCopyCompatibleArrays!(SourceRange, TargetRange) && | ||
| 401 | isInputRange!SourceRange && | ||
| 402 | isOutputRange!(TargetRange, ElementType!SourceRange)) | ||
| 403 | { | ||
| 404 | // Specialize for 2 random access ranges. | ||
| 405 | // Typically 2 random access ranges are faster iterated by common | ||
| 406 | // index than by x.popFront(), y.popFront() pair | ||
| 407 | static if (isRandomAccessRange!SourceRange && | ||
| 408 | hasLength!SourceRange && | ||
| 409 | hasSlicing!TargetRange && | ||
| 410 | isRandomAccessRange!TargetRange && | ||
| 411 | hasLength!TargetRange) | ||
| 412 | { | ||
| 413 | auto len = source.length; | ||
| 414 | foreach (idx; 0 .. len) | ||
| 415 | target[idx] = source[idx]; | ||
| 416 | return target[len .. target.length]; | ||
| 417 | } | ||
| 418 | else | ||
| 419 | { | ||
| 420 | put(target, source); | ||
| 421 | return target; | ||
| 422 | } | ||
| 423 | } | ||
| 424 | |||
| 425 | /// | ||
| 426 | @safe unittest | ||
| 427 | { | ||
| 428 | int[] a = [ 1, 5 ]; | ||
| 429 | int[] b = [ 9, 8 ]; | ||
| 430 | int[] buf = new int[](a.length + b.length + 10); | ||
| 431 | auto rem = a.copy(buf); // copy a into buf | ||
| 432 | rem = b.copy(rem); // copy b into remainder of buf | ||
| 433 | assert(buf[0 .. a.length + b.length] == [1, 5, 9, 8]); | ||
| 434 | assert(rem.length == 10); // unused slots in buf | ||
| 435 | } | ||
| 436 | |||
| 437 | /** | ||
| 438 | As long as the target range elements support assignment from source | ||
| 439 | range elements, different types of ranges are accepted: | ||
| 440 | */ | ||
| 441 | @safe unittest | ||
| 442 | { | ||
| 443 | float[] src = [ 1.0f, 5 ]; | ||
| 444 | double[] dest = new double[src.length]; | ||
| 445 | src.copy(dest); | ||
| 446 | } | ||
| 447 | |||
| 448 | /** | ||
| 449 | To _copy at most $(D n) elements from a range, you may want to use | ||
| 450 | $(REF take, std,range): | ||
| 451 | */ | ||
| 452 | @safe unittest | ||
| 453 | { | ||
| 454 | import std.range; | ||
| 455 | int[] src = [ 1, 5, 8, 9, 10 ]; | ||
| 456 | auto dest = new int[](3); | ||
| 457 | src.take(dest.length).copy(dest); | ||
| 458 | assert(dest == [ 1, 5, 8 ]); | ||
| 459 | } | ||
| 460 | |||
| 461 | /** | ||
| 462 | To _copy just those elements from a range that satisfy a predicate, | ||
| 463 | use $(LREF filter): | ||
| 464 | */ | ||
| 465 | @safe unittest | ||
| 466 | { | ||
| 467 | import std.algorithm.iteration : filter; | ||
| 468 | int[] src = [ 1, 5, 8, 9, 10, 1, 2, 0 ]; | ||
| 469 | auto dest = new int[src.length]; | ||
| 470 | auto rem = src | ||
| 471 | .filter!(a => (a & 1) == 1) | ||
| 472 | .copy(dest); | ||
| 473 | assert(dest[0 .. $ - rem.length] == [ 1, 5, 9, 1 ]); | ||
| 474 | } | ||
| 475 | |||
| 476 | /** | ||
| 477 | $(REF retro, std,range) can be used to achieve behavior similar to | ||
| 478 | $(HTTP sgi.com/tech/stl/copy_backward.html, STL's copy_backward'): | ||
| 479 | */ | ||
| 480 | @safe unittest | ||
| 481 | { | ||
| 482 | import std.algorithm, std.range; | ||
| 483 | int[] src = [1, 2, 4]; | ||
| 484 | int[] dest = [0, 0, 0, 0, 0]; | ||
| 485 | src.retro.copy(dest.retro); | ||
| 486 | assert(dest == [0, 0, 1, 2, 4]); | ||
| 487 | } | ||
| 488 | |||
| 489 | // Test CTFE copy. | ||
| 490 | @safe unittest | ||
| 491 | { | ||
| 492 | enum c = copy([1,2,3], [4,5,6,7]); | ||
| 493 | assert(c == [7]); | ||
| 494 | } | ||
| 495 | |||
| 496 | |||
| 497 | @safe unittest | ||
| 498 | { | ||
| 499 | import std.algorithm.iteration : filter; | ||
| 500 | |||
| 501 | { | ||
| 502 | int[] a = [ 1, 5 ]; | ||
| 503 | int[] b = [ 9, 8 ]; | ||
| 504 | auto e = copy(filter!("a > 1")(a), b); | ||
| 505 | assert(b[0] == 5 && e.length == 1); | ||
| 506 | } | ||
| 507 | |||
| 508 | { | ||
| 509 | int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | ||
| 510 | copy(a[5 .. 10], a[4 .. 9]); | ||
| 511 | assert(a[4 .. 9] == [6, 7, 8, 9, 10]); | ||
| 512 | } | ||
| 513 | |||
| 514 | { // Test for bug 7898 | ||
| 515 | enum v = | ||
| 516 | { | ||
| 517 | import std.algorithm; | ||
| 518 | int[] arr1 = [10, 20, 30, 40, 50]; | ||
| 519 | int[] arr2 = arr1.dup; | ||
| 520 | copy(arr1, arr2); | ||
| 521 | return 35; | ||
| 522 | }(); | ||
| 523 | assert(v == 35); | ||
| 524 | } | ||
| 525 | } | ||
| 526 | |||
| 527 | @safe unittest | ||
| 528 | { | ||
| 529 | // Issue 13650 | ||
| 530 | import std.meta : AliasSeq; | ||
| 531 | foreach (Char; AliasSeq!(char, wchar, dchar)) | ||
| 532 | { | ||
| 533 | Char[3] a1 = "123"; | ||
| 534 | Char[6] a2 = "456789"; | ||
| 535 | assert(copy(a1[], a2[]) is a2[3..$]); | ||
| 536 | assert(a1[] == "123"); | ||
| 537 | assert(a2[] == "123789"); | ||
| 538 | } | ||
| 539 | } | ||
| 540 | |||
| 541 | /** | ||
| 542 | Assigns $(D value) to each element of input _range $(D range). | ||
| 543 | |||
| 544 | Params: | ||
| 545 | range = An | ||
| 546 | $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 547 | that exposes references to its elements and has assignable | ||
| 548 | elements | ||
| 549 | value = Assigned to each element of range | ||
| 550 | |||
| 551 | See_Also: | ||
| 552 | $(LREF uninitializedFill) | ||
| 553 | $(LREF initializeAll) | ||
| 554 | */ | ||
| 555 | void fill(Range, Value)(auto ref Range range, auto ref Value value) | ||
| 556 | if ((isInputRange!Range && is(typeof(range.front = value)) || | ||
| 557 | isSomeChar!Value && is(typeof(range[] = value)))) | ||
| 558 | { | ||
| 559 | alias T = ElementType!Range; | ||
| 560 | |||
| 561 | static if (is(typeof(range[] = value))) | ||
| 562 | { | ||
| 563 | range[] = value; | ||
| 564 | } | ||
| 565 | else static if (is(typeof(range[] = T(value)))) | ||
| 566 | { | ||
| 567 | range[] = T(value); | ||
| 568 | } | ||
| 569 | else | ||
| 570 | { | ||
| 571 | for ( ; !range.empty; range.popFront() ) | ||
| 572 | { | ||
| 573 | range.front = value; | ||
| 574 | } | ||
| 575 | } | ||
| 576 | } | ||
| 577 | |||
| 578 | /// | ||
| 579 | @safe unittest | ||
| 580 | { | ||
| 581 | int[] a = [ 1, 2, 3, 4 ]; | ||
| 582 | fill(a, 5); | ||
| 583 | assert(a == [ 5, 5, 5, 5 ]); | ||
| 584 | } | ||
| 585 | |||
| 586 | // issue 16342, test fallback on mutable narrow strings | ||
| 587 | @safe unittest | ||
| 588 | { | ||
| 589 | char[] chars = ['a', 'b']; | ||
| 590 | fill(chars, 'c'); | ||
| 591 | assert(chars == "cc"); | ||
| 592 | |||
| 593 | char[2] chars2 = ['a', 'b']; | ||
| 594 | fill(chars2, 'c'); | ||
| 595 | assert(chars2 == "cc"); | ||
| 596 | |||
| 597 | wchar[] wchars = ['a', 'b']; | ||
| 598 | fill(wchars, wchar('c')); | ||
| 599 | assert(wchars == "cc"w); | ||
| 600 | |||
| 601 | dchar[] dchars = ['a', 'b']; | ||
| 602 | fill(dchars, dchar('c')); | ||
| 603 | assert(dchars == "cc"d); | ||
| 604 | } | ||
| 605 | |||
| 606 | @nogc @safe unittest | ||
| 607 | { | ||
| 608 | const(char)[] chars; | ||
| 609 | assert(chars.length == 0); | ||
| 610 | static assert(!__traits(compiles, fill(chars, 'c'))); | ||
| 611 | wstring wchars; | ||
| 612 | assert(wchars.length == 0); | ||
| 613 | static assert(!__traits(compiles, fill(wchars, wchar('c')))); | ||
| 614 | } | ||
| 615 | |||
| 616 | @nogc @safe unittest | ||
| 617 | { | ||
| 618 | char[] chars; | ||
| 619 | fill(chars, 'c'); | ||
| 620 | assert(chars == ""c); | ||
| 621 | } | ||
| 622 | |||
| 623 | @safe unittest | ||
| 624 | { | ||
| 625 | shared(char)[] chrs = ['r']; | ||
| 626 | fill(chrs, 'c'); | ||
| 627 | assert(chrs == [shared(char)('c')]); | ||
| 628 | } | ||
| 629 | |||
| 630 | @nogc @safe unittest | ||
| 631 | { | ||
| 632 | struct Str(size_t len) | ||
| 633 | { | ||
| 634 | private char[len] _data; | ||
| 635 | void opIndexAssign(char value) @safe @nogc | ||
| 636 | {_data[] = value;} | ||
| 637 | } | ||
| 638 | Str!2 str; | ||
| 639 | str.fill(':'); | ||
| 640 | assert(str._data == "::"); | ||
| 641 | } | ||
| 642 | |||
| 643 | @safe unittest | ||
| 644 | { | ||
| 645 | char[] chars = ['a','b','c','d']; | ||
| 646 | chars[1 .. 3].fill(':'); | ||
| 647 | assert(chars == "a::d"); | ||
| 648 | } | ||
| 649 | // end issue 16342 | ||
| 650 | |||
| 651 | @safe unittest | ||
| 652 | { | ||
| 653 | import std.conv : text; | ||
| 654 | import std.internal.test.dummyrange; | ||
| 655 | |||
| 656 | int[] a = [ 1, 2, 3 ]; | ||
| 657 | fill(a, 6); | ||
| 658 | assert(a == [ 6, 6, 6 ], text(a)); | ||
| 659 | |||
| 660 | void fun0() | ||
| 661 | { | ||
| 662 | foreach (i; 0 .. 1000) | ||
| 663 | { | ||
| 664 | foreach (ref e; a) e = 6; | ||
| 665 | } | ||
| 666 | } | ||
| 667 | void fun1() { foreach (i; 0 .. 1000) fill(a, 6); } | ||
| 668 | |||
| 669 | // fill should accept InputRange | ||
| 670 | alias InputRange = DummyRange!(ReturnBy.Reference, Length.No, RangeType.Input); | ||
| 671 | enum filler = uint.max; | ||
| 672 | InputRange range; | ||
| 673 | fill(range, filler); | ||
| 674 | foreach (value; range.arr) | ||
| 675 | assert(value == filler); | ||
| 676 | } | ||
| 677 | |||
| 678 | @safe unittest | ||
| 679 | { | ||
| 680 | //ER8638_1 IS_NOT self assignable | ||
| 681 | static struct ER8638_1 | ||
| 682 | { | ||
| 683 | void opAssign(int){} | ||
| 684 | } | ||
| 685 | |||
| 686 | //ER8638_1 IS self assignable | ||
| 687 | static struct ER8638_2 | ||
| 688 | { | ||
| 689 | void opAssign(ER8638_2){} | ||
| 690 | void opAssign(int){} | ||
| 691 | } | ||
| 692 | |||
| 693 | auto er8638_1 = new ER8638_1[](10); | ||
| 694 | auto er8638_2 = new ER8638_2[](10); | ||
| 695 | er8638_1.fill(5); //generic case | ||
| 696 | er8638_2.fill(5); //opSlice(T.init) case | ||
| 697 | } | ||
| 698 | |||
| 699 | @safe unittest | ||
| 700 | { | ||
| 701 | { | ||
| 702 | int[] a = [1, 2, 3]; | ||
| 703 | immutable(int) b = 0; | ||
| 704 | a.fill(b); | ||
| 705 | assert(a == [0, 0, 0]); | ||
| 706 | } | ||
| 707 | { | ||
| 708 | double[] a = [1, 2, 3]; | ||
| 709 | immutable(int) b = 0; | ||
| 710 | a.fill(b); | ||
| 711 | assert(a == [0, 0, 0]); | ||
| 712 | } | ||
| 713 | } | ||
| 714 | |||
| 715 | /** | ||
| 716 | Fills $(D range) with a pattern copied from $(D filler). The length of | ||
| 717 | $(D range) does not have to be a multiple of the length of $(D | ||
| 718 | filler). If $(D filler) is empty, an exception is thrown. | ||
| 719 | |||
| 720 | Params: | ||
| 721 | range = An $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 722 | that exposes references to its elements and has assignable elements. | ||
| 723 | filler = The | ||
| 724 | $(REF_ALTTEXT forward _range, isForwardRange, std,_range,primitives) | ||
| 725 | representing the _fill pattern. | ||
| 726 | */ | ||
| 727 | void fill(InputRange, ForwardRange)(InputRange range, ForwardRange filler) | ||
| 728 | if (isInputRange!InputRange | ||
| 729 | && (isForwardRange!ForwardRange | ||
| 730 | || (isInputRange!ForwardRange && isInfinite!ForwardRange)) | ||
| 731 | && is(typeof(InputRange.init.front = ForwardRange.init.front))) | ||
| 732 | { | ||
| 733 | static if (isInfinite!ForwardRange) | ||
| 734 | { | ||
| 735 | //ForwardRange is infinite, no need for bounds checking or saving | ||
| 736 | static if (hasSlicing!ForwardRange && hasLength!InputRange | ||
| 737 | && is(typeof(filler[0 .. range.length]))) | ||
| 738 | { | ||
| 739 | copy(filler[0 .. range.length], range); | ||
| 740 | } | ||
| 741 | else | ||
| 742 | { | ||
| 743 | //manual feed | ||
| 744 | for ( ; !range.empty; range.popFront(), filler.popFront()) | ||
| 745 | { | ||
| 746 | range.front = filler.front; | ||
| 747 | } | ||
| 748 | } | ||
| 749 | } | ||
| 750 | else | ||
| 751 | { | ||
| 752 | import std.exception : enforce; | ||
| 753 | |||
| 754 | enforce(!filler.empty, "Cannot fill range with an empty filler"); | ||
| 755 | |||
| 756 | static if (hasLength!InputRange && hasLength!ForwardRange | ||
| 757 | && is(typeof(range.length > filler.length))) | ||
| 758 | { | ||
| 759 | //Case we have access to length | ||
| 760 | immutable len = filler.length; | ||
| 761 | //Start by bulk copies | ||
| 762 | while (range.length > len) | ||
| 763 | { | ||
| 764 | range = copy(filler.save, range); | ||
| 765 | } | ||
| 766 | |||
| 767 | //and finally fill the partial range. No need to save here. | ||
| 768 | static if (hasSlicing!ForwardRange && is(typeof(filler[0 .. range.length]))) | ||
| 769 | { | ||
| 770 | //use a quick copy | ||
| 771 | auto len2 = range.length; | ||
| 772 | range = copy(filler[0 .. len2], range); | ||
| 773 | } | ||
| 774 | else | ||
| 775 | { | ||
| 776 | //iterate. No need to check filler, it's length is longer than range's | ||
| 777 | for (; !range.empty; range.popFront(), filler.popFront()) | ||
| 778 | { | ||
| 779 | range.front = filler.front; | ||
| 780 | } | ||
| 781 | } | ||
| 782 | } | ||
| 783 | else | ||
| 784 | { | ||
| 785 | //Most basic case. | ||
| 786 | auto bck = filler.save; | ||
| 787 | for (; !range.empty; range.popFront(), filler.popFront()) | ||
| 788 | { | ||
| 789 | if (filler.empty) filler = bck.save; | ||
| 790 | range.front = filler.front; | ||
| 791 | } | ||
| 792 | } | ||
| 793 | } | ||
| 794 | } | ||
| 795 | |||
| 796 | /// | ||
| 797 | @safe unittest | ||
| 798 | { | ||
| 799 | int[] a = [ 1, 2, 3, 4, 5 ]; | ||
| 800 | int[] b = [ 8, 9 ]; | ||
| 801 | fill(a, b); | ||
| 802 | assert(a == [ 8, 9, 8, 9, 8 ]); | ||
| 803 | } | ||
| 804 | |||
| 805 | @safe unittest | ||
| 806 | { | ||
| 807 | import std.exception : assertThrown; | ||
| 808 | import std.internal.test.dummyrange; | ||
| 809 | |||
| 810 | int[] a = [ 1, 2, 3, 4, 5 ]; | ||
| 811 | int[] b = [1, 2]; | ||
| 812 | fill(a, b); | ||
| 813 | assert(a == [ 1, 2, 1, 2, 1 ]); | ||
| 814 | |||
| 815 | // fill should accept InputRange | ||
| 816 | alias InputRange = DummyRange!(ReturnBy.Reference, Length.No, RangeType.Input); | ||
| 817 | InputRange range; | ||
| 818 | fill(range,[1,2]); | ||
| 819 | foreach (i,value;range.arr) | ||
| 820 | assert(value == (i%2 == 0?1:2)); | ||
| 821 | |||
| 822 | //test with a input being a "reference forward" range | ||
| 823 | fill(a, new ReferenceForwardRange!int([8, 9])); | ||
| 824 | assert(a == [8, 9, 8, 9, 8]); | ||
| 825 | |||
| 826 | //test with a input being an "infinite input" range | ||
| 827 | fill(a, new ReferenceInfiniteInputRange!int()); | ||
| 828 | assert(a == [0, 1, 2, 3, 4]); | ||
| 829 | |||
| 830 | //empty filler test | ||
| 831 | assertThrown(fill(a, a[$..$])); | ||
| 832 | } | ||
| 833 | |||
| 834 | /** | ||
| 835 | Initializes all elements of $(D range) with their $(D .init) value. | ||
| 836 | Assumes that the elements of the range are uninitialized. | ||
| 837 | |||
| 838 | Params: | ||
| 839 | range = An | ||
| 840 | $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 841 | that exposes references to its elements and has assignable | ||
| 842 | elements | ||
| 843 | |||
| 844 | See_Also: | ||
| 845 | $(LREF fill) | ||
| 846 | $(LREF uninitializeFill) | ||
| 847 | */ | ||
| 848 | void initializeAll(Range)(Range range) | ||
| 849 | if (isInputRange!Range && hasLvalueElements!Range && hasAssignableElements!Range) | ||
| 850 | { | ||
| 851 | import core.stdc.string : memset, memcpy; | ||
| 852 | import std.traits : hasElaborateAssign, isDynamicArray; | ||
| 853 | |||
| 854 | alias T = ElementType!Range; | ||
| 855 | static if (hasElaborateAssign!T) | ||
| 856 | { | ||
| 857 | import std.algorithm.internal : addressOf; | ||
| 858 | //Elaborate opAssign. Must go the memcpy road. | ||
| 859 | //We avoid calling emplace here, because our goal is to initialize to | ||
| 860 | //the static state of T.init, | ||
| 861 | //So we want to avoid any un-necassarilly CC'ing of T.init | ||
| 862 | auto p = typeid(T).initializer(); | ||
| 863 | if (p.ptr) | ||
| 864 | { | ||
| 865 | for ( ; !range.empty ; range.popFront() ) | ||
| 866 | { | ||
| 867 | static if (__traits(isStaticArray, T)) | ||
| 868 | { | ||
| 869 | // static array initializer only contains initialization | ||
| 870 | // for one element of the static array. | ||
| 871 | auto elemp = cast(void *) addressOf(range.front); | ||
| 872 | auto endp = elemp + T.sizeof; | ||
| 873 | while (elemp < endp) | ||
| 874 | { | ||
| 875 | memcpy(elemp, p.ptr, p.length); | ||
| 876 | elemp += p.length; | ||
| 877 | } | ||
| 878 | } | ||
| 879 | else | ||
| 880 | { | ||
| 881 | memcpy(addressOf(range.front), p.ptr, T.sizeof); | ||
| 882 | } | ||
| 883 | } | ||
| 884 | } | ||
| 885 | else | ||
| 886 | static if (isDynamicArray!Range) | ||
| 887 | memset(range.ptr, 0, range.length * T.sizeof); | ||
| 888 | else | ||
| 889 | for ( ; !range.empty ; range.popFront() ) | ||
| 890 | memset(addressOf(range.front), 0, T.sizeof); | ||
| 891 | } | ||
| 892 | else | ||
| 893 | fill(range, T.init); | ||
| 894 | } | ||
| 895 | |||
| 896 | /// ditto | ||
| 897 | void initializeAll(Range)(Range range) | ||
| 898 | if (is(Range == char[]) || is(Range == wchar[])) | ||
| 899 | { | ||
| 900 | alias T = ElementEncodingType!Range; | ||
| 901 | range[] = T.init; | ||
| 902 | } | ||
| 903 | |||
| 904 | /// | ||
| 905 | @system unittest | ||
| 906 | { | ||
| 907 | import core.stdc.stdlib : malloc, free; | ||
| 908 | |||
| 909 | struct S | ||
| 910 | { | ||
| 911 | int a = 10; | ||
| 912 | } | ||
| 913 | |||
| 914 | auto s = (cast(S*) malloc(5 * S.sizeof))[0 .. 5]; | ||
| 915 | initializeAll(s); | ||
| 916 | assert(s == [S(10), S(10), S(10), S(10), S(10)]); | ||
| 917 | |||
| 918 | scope(exit) free(s.ptr); | ||
| 919 | } | ||
| 920 | |||
| 921 | @system unittest | ||
| 922 | { | ||
| 923 | import std.algorithm.iteration : filter; | ||
| 924 | import std.meta : AliasSeq; | ||
| 925 | import std.traits : hasElaborateAssign; | ||
| 926 | |||
| 927 | //Test strings: | ||
| 928 | //Must work on narrow strings. | ||
| 929 | //Must reject const | ||
| 930 | char[3] a = void; | ||
| 931 | a[].initializeAll(); | ||
| 932 | assert(a[] == [char.init, char.init, char.init]); | ||
| 933 | string s; | ||
| 934 | assert(!__traits(compiles, s.initializeAll())); | ||
| 935 | assert(!__traits(compiles, s.initializeAll())); | ||
| 936 | assert(s.empty); | ||
| 937 | |||
| 938 | //Note: Cannot call uninitializedFill on narrow strings | ||
| 939 | |||
| 940 | enum e {e1, e2} | ||
| 941 | e[3] b1 = void; | ||
| 942 | b1[].initializeAll(); | ||
| 943 | assert(b1[] == [e.e1, e.e1, e.e1]); | ||
| 944 | e[3] b2 = void; | ||
| 945 | b2[].uninitializedFill(e.e2); | ||
| 946 | assert(b2[] == [e.e2, e.e2, e.e2]); | ||
| 947 | |||
| 948 | static struct S1 | ||
| 949 | { | ||
| 950 | int i; | ||
| 951 | } | ||
| 952 | static struct S2 | ||
| 953 | { | ||
| 954 | int i = 1; | ||
| 955 | } | ||
| 956 | static struct S3 | ||
| 957 | { | ||
| 958 | int i; | ||
| 959 | this(this){} | ||
| 960 | } | ||
| 961 | static struct S4 | ||
| 962 | { | ||
| 963 | int i = 1; | ||
| 964 | this(this){} | ||
| 965 | } | ||
| 966 | static assert(!hasElaborateAssign!S1); | ||
| 967 | static assert(!hasElaborateAssign!S2); | ||
| 968 | static assert( hasElaborateAssign!S3); | ||
| 969 | static assert( hasElaborateAssign!S4); | ||
| 970 | assert(!typeid(S1).initializer().ptr); | ||
| 971 | assert( typeid(S2).initializer().ptr); | ||
| 972 | assert(!typeid(S3).initializer().ptr); | ||
| 973 | assert( typeid(S4).initializer().ptr); | ||
| 974 | |||
| 975 | foreach (S; AliasSeq!(S1, S2, S3, S4)) | ||
| 976 | { | ||
| 977 | //initializeAll | ||
| 978 | { | ||
| 979 | //Array | ||
| 980 | S[3] ss1 = void; | ||
| 981 | ss1[].initializeAll(); | ||
| 982 | assert(ss1[] == [S.init, S.init, S.init]); | ||
| 983 | |||
| 984 | //Not array | ||
| 985 | S[3] ss2 = void; | ||
| 986 | auto sf = ss2[].filter!"true"(); | ||
| 987 | |||
| 988 | sf.initializeAll(); | ||
| 989 | assert(ss2[] == [S.init, S.init, S.init]); | ||
| 990 | } | ||
| 991 | //uninitializedFill | ||
| 992 | { | ||
| 993 | //Array | ||
| 994 | S[3] ss1 = void; | ||
| 995 | ss1[].uninitializedFill(S(2)); | ||
| 996 | assert(ss1[] == [S(2), S(2), S(2)]); | ||
| 997 | |||
| 998 | //Not array | ||
| 999 | S[3] ss2 = void; | ||
| 1000 | auto sf = ss2[].filter!"true"(); | ||
| 1001 | sf.uninitializedFill(S(2)); | ||
| 1002 | assert(ss2[] == [S(2), S(2), S(2)]); | ||
| 1003 | } | ||
| 1004 | } | ||
| 1005 | } | ||
| 1006 | |||
| 1007 | // test that initializeAll works for arrays of static arrays of structs with | ||
| 1008 | // elaborate assigns. | ||
| 1009 | @system unittest | ||
| 1010 | { | ||
| 1011 | struct Int { | ||
| 1012 | ~this() {} | ||
| 1013 | int x = 3; | ||
| 1014 | } | ||
| 1015 | Int[2] xs = [Int(1), Int(2)]; | ||
| 1016 | struct R { | ||
| 1017 | bool done; | ||
| 1018 | bool empty() { return done; } | ||
| 1019 | ref Int[2] front() { return xs; } | ||
| 1020 | void popFront() { done = true; } | ||
| 1021 | } | ||
| 1022 | initializeAll(R()); | ||
| 1023 | assert(xs[0].x == 3); | ||
| 1024 | assert(xs[1].x == 3); | ||
| 1025 | } | ||
| 1026 | |||
| 1027 | // move | ||
| 1028 | /** | ||
| 1029 | Moves `source` into `target`, via a destructive copy when necessary. | ||
| 1030 | |||
| 1031 | If `T` is a struct with a destructor or postblit defined, source is reset | ||
| 1032 | to its `.init` value after it is moved into target, otherwise it is | ||
| 1033 | left unchanged. | ||
| 1034 | |||
| 1035 | Preconditions: | ||
| 1036 | If source has internal pointers that point to itself, it cannot be moved, and | ||
| 1037 | will trigger an assertion failure. | ||
| 1038 | |||
| 1039 | Params: | ||
| 1040 | source = Data to copy. | ||
| 1041 | target = Where to copy into. The destructor, if any, is invoked before the | ||
| 1042 | copy is performed. | ||
| 1043 | */ | ||
| 1044 | void move(T)(ref T source, ref T target) | ||
| 1045 | { | ||
| 1046 | // test @safe destructible | ||
| 1047 | static if (__traits(compiles, (T t) @safe {})) | ||
| 1048 | trustedMoveImpl(source, target); | ||
| 1049 | else | ||
| 1050 | moveImpl(source, target); | ||
| 1051 | } | ||
| 1052 | |||
| 1053 | /// For non-struct types, `move` just performs `target = source`: | ||
| 1054 | @safe unittest | ||
| 1055 | { | ||
| 1056 | Object obj1 = new Object; | ||
| 1057 | Object obj2 = obj1; | ||
| 1058 | Object obj3; | ||
| 1059 | |||
| 1060 | move(obj2, obj3); | ||
| 1061 | assert(obj3 is obj1); | ||
| 1062 | // obj2 unchanged | ||
| 1063 | assert(obj2 is obj1); | ||
| 1064 | } | ||
| 1065 | |||
| 1066 | /// | ||
| 1067 | pure nothrow @safe @nogc unittest | ||
| 1068 | { | ||
| 1069 | // Structs without destructors are simply copied | ||
| 1070 | struct S1 | ||
| 1071 | { | ||
| 1072 | int a = 1; | ||
| 1073 | int b = 2; | ||
| 1074 | } | ||
| 1075 | S1 s11 = { 10, 11 }; | ||
| 1076 | S1 s12; | ||
| 1077 | |||
| 1078 | move(s11, s12); | ||
| 1079 | |||
| 1080 | assert(s12 == S1(10, 11)); | ||
| 1081 | assert(s11 == s12); | ||
| 1082 | |||
| 1083 | // But structs with destructors or postblits are reset to their .init value | ||
| 1084 | // after copying to the target. | ||
| 1085 | struct S2 | ||
| 1086 | { | ||
| 1087 | int a = 1; | ||
| 1088 | int b = 2; | ||
| 1089 | |||
| 1090 | ~this() pure nothrow @safe @nogc { } | ||
| 1091 | } | ||
| 1092 | S2 s21 = { 3, 4 }; | ||
| 1093 | S2 s22; | ||
| 1094 | |||
| 1095 | move(s21, s22); | ||
| 1096 | |||
| 1097 | assert(s21 == S2(1, 2)); | ||
| 1098 | assert(s22 == S2(3, 4)); | ||
| 1099 | } | ||
| 1100 | |||
| 1101 | @safe unittest | ||
| 1102 | { | ||
| 1103 | import std.exception : assertCTFEable; | ||
| 1104 | import std.traits; | ||
| 1105 | |||
| 1106 | assertCTFEable!((){ | ||
| 1107 | Object obj1 = new Object; | ||
| 1108 | Object obj2 = obj1; | ||
| 1109 | Object obj3; | ||
| 1110 | move(obj2, obj3); | ||
| 1111 | assert(obj3 is obj1); | ||
| 1112 | |||
| 1113 | static struct S1 { int a = 1, b = 2; } | ||
| 1114 | S1 s11 = { 10, 11 }; | ||
| 1115 | S1 s12; | ||
| 1116 | move(s11, s12); | ||
| 1117 | assert(s11.a == 10 && s11.b == 11 && s12.a == 10 && s12.b == 11); | ||
| 1118 | |||
| 1119 | static struct S2 { int a = 1; int * b; } | ||
| 1120 | S2 s21 = { 10, null }; | ||
| 1121 | s21.b = new int; | ||
| 1122 | S2 s22; | ||
| 1123 | move(s21, s22); | ||
| 1124 | assert(s21 == s22); | ||
| 1125 | }); | ||
| 1126 | // Issue 5661 test(1) | ||
| 1127 | static struct S3 | ||
| 1128 | { | ||
| 1129 | static struct X { int n = 0; ~this(){n = 0;} } | ||
| 1130 | X x; | ||
| 1131 | } | ||
| 1132 | static assert(hasElaborateDestructor!S3); | ||
| 1133 | S3 s31, s32; | ||
| 1134 | s31.x.n = 1; | ||
| 1135 | move(s31, s32); | ||
| 1136 | assert(s31.x.n == 0); | ||
| 1137 | assert(s32.x.n == 1); | ||
| 1138 | |||
| 1139 | // Issue 5661 test(2) | ||
| 1140 | static struct S4 | ||
| 1141 | { | ||
| 1142 | static struct X { int n = 0; this(this){n = 0;} } | ||
| 1143 | X x; | ||
| 1144 | } | ||
| 1145 | static assert(hasElaborateCopyConstructor!S4); | ||
| 1146 | S4 s41, s42; | ||
| 1147 | s41.x.n = 1; | ||
| 1148 | move(s41, s42); | ||
| 1149 | assert(s41.x.n == 0); | ||
| 1150 | assert(s42.x.n == 1); | ||
| 1151 | |||
| 1152 | // Issue 13990 test | ||
| 1153 | class S5; | ||
| 1154 | |||
| 1155 | S5 s51; | ||
| 1156 | S5 s52 = s51; | ||
| 1157 | S5 s53; | ||
| 1158 | move(s52, s53); | ||
| 1159 | assert(s53 is s51); | ||
| 1160 | } | ||
| 1161 | |||
| 1162 | /// Ditto | ||
| 1163 | T move(T)(ref T source) | ||
| 1164 | { | ||
| 1165 | // test @safe destructible | ||
| 1166 | static if (__traits(compiles, (T t) @safe {})) | ||
| 1167 | return trustedMoveImpl(source); | ||
| 1168 | else | ||
| 1169 | return moveImpl(source); | ||
| 1170 | } | ||
| 1171 | |||
| 1172 | /// Non-copyable structs can still be moved: | ||
| 1173 | pure nothrow @safe @nogc unittest | ||
| 1174 | { | ||
| 1175 | struct S | ||
| 1176 | { | ||
| 1177 | int a = 1; | ||
| 1178 | @disable this(this); | ||
| 1179 | ~this() pure nothrow @safe @nogc {} | ||
| 1180 | } | ||
| 1181 | S s1; | ||
| 1182 | s1.a = 2; | ||
| 1183 | S s2 = move(s1); | ||
| 1184 | assert(s1.a == 1); | ||
| 1185 | assert(s2.a == 2); | ||
| 1186 | } | ||
| 1187 | |||
| 1188 | private void trustedMoveImpl(T)(ref T source, ref T target) @trusted | ||
| 1189 | { | ||
| 1190 | moveImpl(source, target); | ||
| 1191 | } | ||
| 1192 | |||
| 1193 | private void moveImpl(T)(ref T source, ref T target) | ||
| 1194 | { | ||
| 1195 | import std.traits : hasElaborateDestructor; | ||
| 1196 | |||
| 1197 | static if (is(T == struct)) | ||
| 1198 | { | ||
| 1199 | if (&source == &target) return; | ||
| 1200 | // Destroy target before overwriting it | ||
| 1201 | static if (hasElaborateDestructor!T) target.__xdtor(); | ||
| 1202 | } | ||
| 1203 | // move and emplace source into target | ||
| 1204 | moveEmplace(source, target); | ||
| 1205 | } | ||
| 1206 | |||
| 1207 | private T trustedMoveImpl(T)(ref T source) @trusted | ||
| 1208 | { | ||
| 1209 | return moveImpl(source); | ||
| 1210 | } | ||
| 1211 | |||
| 1212 | private T moveImpl(T)(ref T source) | ||
| 1213 | { | ||
| 1214 | T result = void; | ||
| 1215 | moveEmplace(source, result); | ||
| 1216 | return result; | ||
| 1217 | } | ||
| 1218 | |||
| 1219 | @safe unittest | ||
| 1220 | { | ||
| 1221 | import std.exception : assertCTFEable; | ||
| 1222 | import std.traits; | ||
| 1223 | |||
| 1224 | assertCTFEable!((){ | ||
| 1225 | Object obj1 = new Object; | ||
| 1226 | Object obj2 = obj1; | ||
| 1227 | Object obj3 = move(obj2); | ||
| 1228 | assert(obj3 is obj1); | ||
| 1229 | |||
| 1230 | static struct S1 { int a = 1, b = 2; } | ||
| 1231 | S1 s11 = { 10, 11 }; | ||
| 1232 | S1 s12 = move(s11); | ||
| 1233 | assert(s11.a == 10 && s11.b == 11 && s12.a == 10 && s12.b == 11); | ||
| 1234 | |||
| 1235 | static struct S2 { int a = 1; int * b; } | ||
| 1236 | S2 s21 = { 10, null }; | ||
| 1237 | s21.b = new int; | ||
| 1238 | S2 s22 = move(s21); | ||
| 1239 | assert(s21 == s22); | ||
| 1240 | }); | ||
| 1241 | |||
| 1242 | // Issue 5661 test(1) | ||
| 1243 | static struct S3 | ||
| 1244 | { | ||
| 1245 | static struct X { int n = 0; ~this(){n = 0;} } | ||
| 1246 | X x; | ||
| 1247 | } | ||
| 1248 | static assert(hasElaborateDestructor!S3); | ||
| 1249 | S3 s31; | ||
| 1250 | s31.x.n = 1; | ||
| 1251 | S3 s32 = move(s31); | ||
| 1252 | assert(s31.x.n == 0); | ||
| 1253 | assert(s32.x.n == 1); | ||
| 1254 | |||
| 1255 | // Issue 5661 test(2) | ||
| 1256 | static struct S4 | ||
| 1257 | { | ||
| 1258 | static struct X { int n = 0; this(this){n = 0;} } | ||
| 1259 | X x; | ||
| 1260 | } | ||
| 1261 | static assert(hasElaborateCopyConstructor!S4); | ||
| 1262 | S4 s41; | ||
| 1263 | s41.x.n = 1; | ||
| 1264 | S4 s42 = move(s41); | ||
| 1265 | assert(s41.x.n == 0); | ||
| 1266 | assert(s42.x.n == 1); | ||
| 1267 | |||
| 1268 | // Issue 13990 test | ||
| 1269 | class S5; | ||
| 1270 | |||
| 1271 | S5 s51; | ||
| 1272 | S5 s52 = s51; | ||
| 1273 | S5 s53; | ||
| 1274 | s53 = move(s52); | ||
| 1275 | assert(s53 is s51); | ||
| 1276 | } | ||
| 1277 | |||
| 1278 | @system unittest | ||
| 1279 | { | ||
| 1280 | static struct S { int n = 0; ~this() @system { n = 0; } } | ||
| 1281 | S a, b; | ||
| 1282 | static assert(!__traits(compiles, () @safe { move(a, b); })); | ||
| 1283 | static assert(!__traits(compiles, () @safe { move(a); })); | ||
| 1284 | a.n = 1; | ||
| 1285 | () @trusted { move(a, b); }(); | ||
| 1286 | assert(a.n == 0); | ||
| 1287 | a.n = 1; | ||
| 1288 | () @trusted { move(a); }(); | ||
| 1289 | assert(a.n == 0); | ||
| 1290 | } | ||
| 1291 | |||
| 1292 | @safe unittest//Issue 6217 | ||
| 1293 | { | ||
| 1294 | import std.algorithm.iteration : map; | ||
| 1295 | auto x = map!"a"([1,2,3]); | ||
| 1296 | x = move(x); | ||
| 1297 | } | ||
| 1298 | |||
| 1299 | @safe unittest// Issue 8055 | ||
| 1300 | { | ||
| 1301 | static struct S | ||
| 1302 | { | ||
| 1303 | int x; | ||
| 1304 | ~this() | ||
| 1305 | { | ||
| 1306 | assert(x == 0); | ||
| 1307 | } | ||
| 1308 | } | ||
| 1309 | S foo(S s) | ||
| 1310 | { | ||
| 1311 | return move(s); | ||
| 1312 | } | ||
| 1313 | S a; | ||
| 1314 | a.x = 0; | ||
| 1315 | auto b = foo(a); | ||
| 1316 | assert(b.x == 0); | ||
| 1317 | } | ||
| 1318 | |||
| 1319 | @system unittest// Issue 8057 | ||
| 1320 | { | ||
| 1321 | int n = 10; | ||
| 1322 | struct S | ||
| 1323 | { | ||
| 1324 | int x; | ||
| 1325 | ~this() | ||
| 1326 | { | ||
| 1327 | // Access to enclosing scope | ||
| 1328 | assert(n == 10); | ||
| 1329 | } | ||
| 1330 | } | ||
| 1331 | S foo(S s) | ||
| 1332 | { | ||
| 1333 | // Move nested struct | ||
| 1334 | return move(s); | ||
| 1335 | } | ||
| 1336 | S a; | ||
| 1337 | a.x = 1; | ||
| 1338 | auto b = foo(a); | ||
| 1339 | assert(b.x == 1); | ||
| 1340 | |||
| 1341 | // Regression 8171 | ||
| 1342 | static struct Array(T) | ||
| 1343 | { | ||
| 1344 | // nested struct has no member | ||
| 1345 | struct Payload | ||
| 1346 | { | ||
| 1347 | ~this() {} | ||
| 1348 | } | ||
| 1349 | } | ||
| 1350 | Array!int.Payload x = void; | ||
| 1351 | move(x); | ||
| 1352 | move(x, x); | ||
| 1353 | } | ||
| 1354 | |||
| 1355 | /** | ||
| 1356 | * Similar to $(LREF move) but assumes `target` is uninitialized. This | ||
| 1357 | * is more efficient because `source` can be blitted over `target` | ||
| 1358 | * without destroying or initializing it first. | ||
| 1359 | * | ||
| 1360 | * Params: | ||
| 1361 | * source = value to be moved into target | ||
| 1362 | * target = uninitialized value to be filled by source | ||
| 1363 | */ | ||
| 1364 | void moveEmplace(T)(ref T source, ref T target) @system | ||
| 1365 | { | ||
| 1366 | import core.stdc.string : memcpy, memset; | ||
| 1367 | import std.traits : hasAliasing, hasElaborateAssign, | ||
| 1368 | hasElaborateCopyConstructor, hasElaborateDestructor, | ||
| 1369 | isAssignable; | ||
| 1370 | |||
| 1371 | static if (!is(T == class) && hasAliasing!T) if (!__ctfe) | ||
| 1372 | { | ||
| 1373 | import std.exception : doesPointTo; | ||
| 1374 | assert(!doesPointTo(source, source), "Cannot move object with internal pointer."); | ||
| 1375 | } | ||
| 1376 | |||
| 1377 | static if (is(T == struct)) | ||
| 1378 | { | ||
| 1379 | assert(&source !is &target, "source and target must not be identical"); | ||
| 1380 | |||
| 1381 | static if (hasElaborateAssign!T || !isAssignable!T) | ||
| 1382 | memcpy(&target, &source, T.sizeof); | ||
| 1383 | else | ||
| 1384 | target = source; | ||
| 1385 | |||
| 1386 | // If the source defines a destructor or a postblit hook, we must obliterate the | ||
| 1387 | // object in order to avoid double freeing and undue aliasing | ||
| 1388 | static if (hasElaborateDestructor!T || hasElaborateCopyConstructor!T) | ||
| 1389 | { | ||
| 1390 | // If T is nested struct, keep original context pointer | ||
| 1391 | static if (__traits(isNested, T)) | ||
| 1392 | enum sz = T.sizeof - (void*).sizeof; | ||
| 1393 | else | ||
| 1394 | enum sz = T.sizeof; | ||
| 1395 | |||
| 1396 | auto init = typeid(T).initializer(); | ||
| 1397 | if (init.ptr is null) // null ptr means initialize to 0s | ||
| 1398 | memset(&source, 0, sz); | ||
| 1399 | else | ||
| 1400 | memcpy(&source, init.ptr, sz); | ||
| 1401 | } | ||
| 1402 | } | ||
| 1403 | else | ||
| 1404 | { | ||
| 1405 | // Primitive data (including pointers and arrays) or class - | ||
| 1406 | // assignment works great | ||
| 1407 | target = source; | ||
| 1408 | } | ||
| 1409 | } | ||
| 1410 | |||
| 1411 | /// | ||
| 1412 | pure nothrow @nogc @system unittest | ||
| 1413 | { | ||
| 1414 | static struct Foo | ||
| 1415 | { | ||
| 1416 | pure nothrow @nogc: | ||
| 1417 | this(int* ptr) { _ptr = ptr; } | ||
| 1418 | ~this() { if (_ptr) ++*_ptr; } | ||
| 1419 | int* _ptr; | ||
| 1420 | } | ||
| 1421 | |||
| 1422 | int val; | ||
| 1423 | Foo foo1 = void; // uninitialized | ||
| 1424 | auto foo2 = Foo(&val); // initialized | ||
| 1425 | assert(foo2._ptr is &val); | ||
| 1426 | |||
| 1427 | // Using `move(foo2, foo1)` would have an undefined effect because it would destroy | ||
| 1428 | // the uninitialized foo1. | ||
| 1429 | // moveEmplace directly overwrites foo1 without destroying or initializing it first. | ||
| 1430 | moveEmplace(foo2, foo1); | ||
| 1431 | assert(foo1._ptr is &val); | ||
| 1432 | assert(foo2._ptr is null); | ||
| 1433 | assert(val == 0); | ||
| 1434 | } | ||
| 1435 | |||
| 1436 | // moveAll | ||
| 1437 | /** | ||
| 1438 | Calls `move(a, b)` for each element `a` in `src` and the corresponding | ||
| 1439 | element `b` in `tgt`, in increasing order. | ||
| 1440 | |||
| 1441 | Preconditions: | ||
| 1442 | `walkLength(src) <= walkLength(tgt)`. | ||
| 1443 | This precondition will be asserted. If you cannot ensure there is enough room in | ||
| 1444 | `tgt` to accommodate all of `src` use $(LREF moveSome) instead. | ||
| 1445 | |||
| 1446 | Params: | ||
| 1447 | src = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with | ||
| 1448 | movable elements. | ||
| 1449 | tgt = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with | ||
| 1450 | elements that elements from $(D src) can be moved into. | ||
| 1451 | |||
| 1452 | Returns: The leftover portion of $(D tgt) after all elements from $(D src) have | ||
| 1453 | been moved. | ||
| 1454 | */ | ||
| 1455 | InputRange2 moveAll(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) | ||
| 1456 | if (isInputRange!InputRange1 && isInputRange!InputRange2 | ||
| 1457 | && is(typeof(move(src.front, tgt.front)))) | ||
| 1458 | { | ||
| 1459 | return moveAllImpl!move(src, tgt); | ||
| 1460 | } | ||
| 1461 | |||
| 1462 | /// | ||
| 1463 | pure nothrow @safe @nogc unittest | ||
| 1464 | { | ||
| 1465 | int[3] a = [ 1, 2, 3 ]; | ||
| 1466 | int[5] b; | ||
| 1467 | assert(moveAll(a[], b[]) is b[3 .. $]); | ||
| 1468 | assert(a[] == b[0 .. 3]); | ||
| 1469 | int[3] cmp = [ 1, 2, 3 ]; | ||
| 1470 | assert(a[] == cmp[]); | ||
| 1471 | } | ||
| 1472 | |||
| 1473 | /** | ||
| 1474 | * Similar to $(LREF moveAll) but assumes all elements in `tgt` are | ||
| 1475 | * uninitialized. Uses $(LREF moveEmplace) to move elements from | ||
| 1476 | * `src` over elements from `tgt`. | ||
| 1477 | */ | ||
| 1478 | InputRange2 moveEmplaceAll(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) @system | ||
| 1479 | if (isInputRange!InputRange1 && isInputRange!InputRange2 | ||
| 1480 | && is(typeof(moveEmplace(src.front, tgt.front)))) | ||
| 1481 | { | ||
| 1482 | return moveAllImpl!moveEmplace(src, tgt); | ||
| 1483 | } | ||
| 1484 | |||
| 1485 | /// | ||
| 1486 | pure nothrow @nogc @system unittest | ||
| 1487 | { | ||
| 1488 | static struct Foo | ||
| 1489 | { | ||
| 1490 | ~this() pure nothrow @nogc { if (_ptr) ++*_ptr; } | ||
| 1491 | int* _ptr; | ||
| 1492 | } | ||
| 1493 | int[3] refs = [0, 1, 2]; | ||
| 1494 | Foo[3] src = [Foo(&refs[0]), Foo(&refs[1]), Foo(&refs[2])]; | ||
| 1495 | Foo[5] dst = void; | ||
| 1496 | |||
| 1497 | auto tail = moveEmplaceAll(src[], dst[]); // move 3 value from src over dst | ||
| 1498 | assert(tail.length == 2); // returns remaining uninitialized values | ||
| 1499 | initializeAll(tail); | ||
| 1500 | |||
| 1501 | import std.algorithm.searching : all; | ||
| 1502 | assert(src[].all!(e => e._ptr is null)); | ||
| 1503 | assert(dst[0 .. 3].all!(e => e._ptr !is null)); | ||
| 1504 | } | ||
| 1505 | |||
| 1506 | @system unittest | ||
| 1507 | { | ||
| 1508 | struct InputRange | ||
| 1509 | { | ||
| 1510 | ref int front() { return data[0]; } | ||
| 1511 | void popFront() { data.popFront; } | ||
| 1512 | bool empty() { return data.empty; } | ||
| 1513 | int[] data; | ||
| 1514 | } | ||
| 1515 | auto a = InputRange([ 1, 2, 3 ]); | ||
| 1516 | auto b = InputRange(new int[5]); | ||
| 1517 | moveAll(a, b); | ||
| 1518 | assert(a.data == b.data[0 .. 3]); | ||
| 1519 | assert(a.data == [ 1, 2, 3 ]); | ||
| 1520 | } | ||
| 1521 | |||
| 1522 | private InputRange2 moveAllImpl(alias moveOp, InputRange1, InputRange2)( | ||
| 1523 | ref InputRange1 src, ref InputRange2 tgt) | ||
| 1524 | { | ||
| 1525 | import std.exception : enforce; | ||
| 1526 | |||
| 1527 | static if (isRandomAccessRange!InputRange1 && hasLength!InputRange1 && hasLength!InputRange2 | ||
| 1528 | && hasSlicing!InputRange2 && isRandomAccessRange!InputRange2) | ||
| 1529 | { | ||
| 1530 | auto toMove = src.length; | ||
| 1531 | assert(toMove <= tgt.length); | ||
| 1532 | foreach (idx; 0 .. toMove) | ||
| 1533 | moveOp(src[idx], tgt[idx]); | ||
| 1534 | return tgt[toMove .. tgt.length]; | ||
| 1535 | } | ||
| 1536 | else | ||
| 1537 | { | ||
| 1538 | for (; !src.empty; src.popFront(), tgt.popFront()) | ||
| 1539 | { | ||
| 1540 | assert(!tgt.empty); | ||
| 1541 | moveOp(src.front, tgt.front); | ||
| 1542 | } | ||
| 1543 | return tgt; | ||
| 1544 | } | ||
| 1545 | } | ||
| 1546 | |||
| 1547 | // moveSome | ||
| 1548 | /** | ||
| 1549 | Calls `move(a, b)` for each element `a` in `src` and the corresponding | ||
| 1550 | element `b` in `tgt`, in increasing order, stopping when either range has been | ||
| 1551 | exhausted. | ||
| 1552 | |||
| 1553 | Params: | ||
| 1554 | src = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with | ||
| 1555 | movable elements. | ||
| 1556 | tgt = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with | ||
| 1557 | elements that elements from $(D src) can be moved into. | ||
| 1558 | |||
| 1559 | Returns: The leftover portions of the two ranges after one or the other of the | ||
| 1560 | ranges have been exhausted. | ||
| 1561 | */ | ||
| 1562 | Tuple!(InputRange1, InputRange2) moveSome(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) | ||
| 1563 | if (isInputRange!InputRange1 && isInputRange!InputRange2 | ||
| 1564 | && is(typeof(move(src.front, tgt.front)))) | ||
| 1565 | { | ||
| 1566 | return moveSomeImpl!move(src, tgt); | ||
| 1567 | } | ||
| 1568 | |||
| 1569 | /// | ||
| 1570 | pure nothrow @safe @nogc unittest | ||
| 1571 | { | ||
| 1572 | int[5] a = [ 1, 2, 3, 4, 5 ]; | ||
| 1573 | int[3] b; | ||
| 1574 | assert(moveSome(a[], b[])[0] is a[3 .. $]); | ||
| 1575 | assert(a[0 .. 3] == b); | ||
| 1576 | assert(a == [ 1, 2, 3, 4, 5 ]); | ||
| 1577 | } | ||
| 1578 | |||
| 1579 | /** | ||
| 1580 | * Same as $(LREF moveSome) but assumes all elements in `tgt` are | ||
| 1581 | * uninitialized. Uses $(LREF moveEmplace) to move elements from | ||
| 1582 | * `src` over elements from `tgt`. | ||
| 1583 | */ | ||
| 1584 | Tuple!(InputRange1, InputRange2) moveEmplaceSome(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) @system | ||
| 1585 | if (isInputRange!InputRange1 && isInputRange!InputRange2 | ||
| 1586 | && is(typeof(move(src.front, tgt.front)))) | ||
| 1587 | { | ||
| 1588 | return moveSomeImpl!moveEmplace(src, tgt); | ||
| 1589 | } | ||
| 1590 | |||
| 1591 | /// | ||
| 1592 | pure nothrow @nogc @system unittest | ||
| 1593 | { | ||
| 1594 | static struct Foo | ||
| 1595 | { | ||
| 1596 | ~this() pure nothrow @nogc { if (_ptr) ++*_ptr; } | ||
| 1597 | int* _ptr; | ||
| 1598 | } | ||
| 1599 | int[4] refs = [0, 1, 2, 3]; | ||
| 1600 | Foo[4] src = [Foo(&refs[0]), Foo(&refs[1]), Foo(&refs[2]), Foo(&refs[3])]; | ||
| 1601 | Foo[3] dst = void; | ||
| 1602 | |||
| 1603 | auto res = moveEmplaceSome(src[], dst[]); | ||
| 1604 | assert(res.length == 2); | ||
| 1605 | |||
| 1606 | import std.algorithm.searching : all; | ||
| 1607 | assert(src[0 .. 3].all!(e => e._ptr is null)); | ||
| 1608 | assert(src[3]._ptr !is null); | ||
| 1609 | assert(dst[].all!(e => e._ptr !is null)); | ||
| 1610 | } | ||
| 1611 | |||
| 1612 | private Tuple!(InputRange1, InputRange2) moveSomeImpl(alias moveOp, InputRange1, InputRange2)( | ||
| 1613 | ref InputRange1 src, ref InputRange2 tgt) | ||
| 1614 | { | ||
| 1615 | for (; !src.empty && !tgt.empty; src.popFront(), tgt.popFront()) | ||
| 1616 | moveOp(src.front, tgt.front); | ||
| 1617 | return tuple(src, tgt); | ||
| 1618 | } | ||
| 1619 | |||
| 1620 | |||
| 1621 | // SwapStrategy | ||
| 1622 | /** | ||
| 1623 | Defines the swapping strategy for algorithms that need to swap | ||
| 1624 | elements in a range (such as partition and sort). The strategy | ||
| 1625 | concerns the swapping of elements that are not the core concern of the | ||
| 1626 | algorithm. For example, consider an algorithm that sorts $(D [ "abc", | ||
| 1627 | "b", "aBc" ]) according to $(D toUpper(a) < toUpper(b)). That | ||
| 1628 | algorithm might choose to swap the two equivalent strings $(D "abc") | ||
| 1629 | and $(D "aBc"). That does not affect the sorting since both $(D [ | ||
| 1630 | "abc", "aBc", "b" ]) and $(D [ "aBc", "abc", "b" ]) are valid | ||
| 1631 | outcomes. | ||
| 1632 | |||
| 1633 | Some situations require that the algorithm must NOT ever change the | ||
| 1634 | relative ordering of equivalent elements (in the example above, only | ||
| 1635 | $(D [ "abc", "aBc", "b" ]) would be the correct result). Such | ||
| 1636 | algorithms are called $(B stable). If the ordering algorithm may swap | ||
| 1637 | equivalent elements discretionarily, the ordering is called $(B | ||
| 1638 | unstable). | ||
| 1639 | |||
| 1640 | Yet another class of algorithms may choose an intermediate tradeoff by | ||
| 1641 | being stable only on a well-defined subrange of the range. There is no | ||
| 1642 | established terminology for such behavior; this library calls it $(B | ||
| 1643 | semistable). | ||
| 1644 | |||
| 1645 | Generally, the $(D stable) ordering strategy may be more costly in | ||
| 1646 | time and/or space than the other two because it imposes additional | ||
| 1647 | constraints. Similarly, $(D semistable) may be costlier than $(D | ||
| 1648 | unstable). As (semi-)stability is not needed very often, the ordering | ||
| 1649 | algorithms in this module parameterized by $(D SwapStrategy) all | ||
| 1650 | choose $(D SwapStrategy.unstable) as the default. | ||
| 1651 | */ | ||
| 1652 | |||
| 1653 | enum SwapStrategy | ||
| 1654 | { | ||
| 1655 | /** | ||
| 1656 | Allows freely swapping of elements as long as the output | ||
| 1657 | satisfies the algorithm's requirements. | ||
| 1658 | */ | ||
| 1659 | unstable, | ||
| 1660 | /** | ||
| 1661 | In algorithms partitioning ranges in two, preserve relative | ||
| 1662 | ordering of elements only to the left of the partition point. | ||
| 1663 | */ | ||
| 1664 | semistable, | ||
| 1665 | /** | ||
| 1666 | Preserve the relative ordering of elements to the largest | ||
| 1667 | extent allowed by the algorithm's requirements. | ||
| 1668 | */ | ||
| 1669 | stable, | ||
| 1670 | } | ||
| 1671 | |||
| 1672 | /// | ||
| 1673 | @safe unittest | ||
| 1674 | { | ||
| 1675 | import std.stdio; | ||
| 1676 | import std.algorithm.sorting : partition; | ||
| 1677 | int[] a = [0, 1, 2, 3]; | ||
| 1678 | assert(remove!(SwapStrategy.stable)(a, 1) == [0, 2, 3]); | ||
| 1679 | a = [0, 1, 2, 3]; | ||
| 1680 | assert(remove!(SwapStrategy.unstable)(a, 1) == [0, 3, 2]); | ||
| 1681 | } | ||
| 1682 | |||
| 1683 | /// | ||
| 1684 | @safe unittest | ||
| 1685 | { | ||
| 1686 | import std.algorithm.sorting : partition; | ||
| 1687 | |||
| 1688 | // Put stuff greater than 3 on the left | ||
| 1689 | auto arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | ||
| 1690 | assert(partition!(a => a > 3, SwapStrategy.stable)(arr) == [1, 2, 3]); | ||
| 1691 | assert(arr == [4, 5, 6, 7, 8, 9, 10, 1, 2, 3]); | ||
| 1692 | |||
| 1693 | arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | ||
| 1694 | assert(partition!(a => a > 3, SwapStrategy.semistable)(arr) == [2, 3, 1]); | ||
| 1695 | assert(arr == [4, 5, 6, 7, 8, 9, 10, 2, 3, 1]); | ||
| 1696 | |||
| 1697 | arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | ||
| 1698 | assert(partition!(a => a > 3, SwapStrategy.unstable)(arr) == [3, 2, 1]); | ||
| 1699 | assert(arr == [10, 9, 8, 4, 5, 6, 7, 3, 2, 1]); | ||
| 1700 | } | ||
| 1701 | |||
| 1702 | /** | ||
| 1703 | Eliminates elements at given offsets from `range` and returns the shortened | ||
| 1704 | range. | ||
| 1705 | |||
| 1706 | For example, here is how to _remove a single element from an array: | ||
| 1707 | |||
| 1708 | ---- | ||
| 1709 | string[] a = [ "a", "b", "c", "d" ]; | ||
| 1710 | a = a.remove(1); // remove element at offset 1 | ||
| 1711 | assert(a == [ "a", "c", "d"]); | ||
| 1712 | ---- | ||
| 1713 | |||
| 1714 | Note that `remove` does not change the length of the original _range directly; | ||
| 1715 | instead, it returns the shortened _range. If its return value is not assigned to | ||
| 1716 | the original _range, the original _range will retain its original length, though | ||
| 1717 | its contents will have changed: | ||
| 1718 | |||
| 1719 | ---- | ||
| 1720 | int[] a = [ 3, 5, 7, 8 ]; | ||
| 1721 | assert(remove(a, 1) == [ 3, 7, 8 ]); | ||
| 1722 | assert(a == [ 3, 7, 8, 8 ]); | ||
| 1723 | ---- | ||
| 1724 | |||
| 1725 | The element at _offset `1` has been removed and the rest of the elements have | ||
| 1726 | shifted up to fill its place, however, the original array remains of the same | ||
| 1727 | length. This is because all functions in `std.algorithm` only change $(I | ||
| 1728 | content), not $(I topology). The value `8` is repeated because $(LREF move) was | ||
| 1729 | invoked to rearrange elements, and on integers `move` simply copies the source | ||
| 1730 | to the destination. To replace `a` with the effect of the removal, simply | ||
| 1731 | assign the slice returned by `remove` to it, as shown in the first example. | ||
| 1732 | |||
| 1733 | Multiple indices can be passed into $(D remove). In that case, | ||
| 1734 | elements at the respective indices are all removed. The indices must | ||
| 1735 | be passed in increasing order, otherwise an exception occurs. | ||
| 1736 | |||
| 1737 | ---- | ||
| 1738 | int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1739 | assert(remove(a, 1, 3, 5) == | ||
| 1740 | [ 0, 2, 4, 6, 7, 8, 9, 10 ]); | ||
| 1741 | ---- | ||
| 1742 | |||
| 1743 | (Note that all indices refer to slots in the $(I original) array, not | ||
| 1744 | in the array as it is being progressively shortened.) Finally, any | ||
| 1745 | combination of integral offsets and tuples composed of two integral | ||
| 1746 | offsets can be passed in. | ||
| 1747 | |||
| 1748 | ---- | ||
| 1749 | int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1750 | assert(remove(a, 1, tuple(3, 5), 9) == [ 0, 2, 5, 6, 7, 8, 10 ]); | ||
| 1751 | ---- | ||
| 1752 | |||
| 1753 | In this case, the slots at positions 1, 3, 4, and 9 are removed from | ||
| 1754 | the array. The tuple passes in a range closed to the left and open to | ||
| 1755 | the right (consistent with built-in slices), e.g. $(D tuple(3, 5)) | ||
| 1756 | means indices $(D 3) and $(D 4) but not $(D 5). | ||
| 1757 | |||
| 1758 | If the need is to remove some elements in the range but the order of | ||
| 1759 | the remaining elements does not have to be preserved, you may want to | ||
| 1760 | pass $(D SwapStrategy.unstable) to $(D remove). | ||
| 1761 | |||
| 1762 | ---- | ||
| 1763 | int[] a = [ 0, 1, 2, 3 ]; | ||
| 1764 | assert(remove!(SwapStrategy.unstable)(a, 1) == [ 0, 3, 2 ]); | ||
| 1765 | ---- | ||
| 1766 | |||
| 1767 | In the case above, the element at slot $(D 1) is removed, but replaced | ||
| 1768 | with the last element of the range. Taking advantage of the relaxation | ||
| 1769 | of the stability requirement, $(D remove) moved elements from the end | ||
| 1770 | of the array over the slots to be removed. This way there is less data | ||
| 1771 | movement to be done which improves the execution time of the function. | ||
| 1772 | |||
| 1773 | The function $(D remove) works on bidirectional ranges that have assignable | ||
| 1774 | lvalue elements. The moving strategy is (listed from fastest to slowest): | ||
| 1775 | $(UL $(LI If $(D s == SwapStrategy.unstable && isRandomAccessRange!Range && | ||
| 1776 | hasLength!Range && hasLvalueElements!Range), then elements are moved from the | ||
| 1777 | end of the range into the slots to be filled. In this case, the absolute | ||
| 1778 | minimum of moves is performed.) $(LI Otherwise, if $(D s == | ||
| 1779 | SwapStrategy.unstable && isBidirectionalRange!Range && hasLength!Range | ||
| 1780 | && hasLvalueElements!Range), then elements are still moved from the | ||
| 1781 | end of the range, but time is spent on advancing between slots by repeated | ||
| 1782 | calls to $(D range.popFront).) $(LI Otherwise, elements are moved | ||
| 1783 | incrementally towards the front of $(D range); a given element is never | ||
| 1784 | moved several times, but more elements are moved than in the previous | ||
| 1785 | cases.)) | ||
| 1786 | |||
| 1787 | Params: | ||
| 1788 | s = a SwapStrategy to determine if the original order needs to be preserved | ||
| 1789 | range = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,_range,primitives) | ||
| 1790 | with a length member | ||
| 1791 | offset = which element(s) to remove | ||
| 1792 | |||
| 1793 | Returns: | ||
| 1794 | a range containing all of the elements of range with offset removed | ||
| 1795 | */ | ||
| 1796 | Range remove | ||
| 1797 | (SwapStrategy s = SwapStrategy.stable, Range, Offset...) | ||
| 1798 | (Range range, Offset offset) | ||
| 1799 | if (s != SwapStrategy.stable | ||
| 1800 | && isBidirectionalRange!Range | ||
| 1801 | && hasLvalueElements!Range | ||
| 1802 | && hasLength!Range | ||
| 1803 | && Offset.length >= 1) | ||
| 1804 | { | ||
| 1805 | Tuple!(size_t, "pos", size_t, "len")[offset.length] blackouts; | ||
| 1806 | foreach (i, v; offset) | ||
| 1807 | { | ||
| 1808 | static if (is(typeof(v[0]) : size_t) && is(typeof(v[1]) : size_t)) | ||
| 1809 | { | ||
| 1810 | blackouts[i].pos = v[0]; | ||
| 1811 | blackouts[i].len = v[1] - v[0]; | ||
| 1812 | } | ||
| 1813 | else | ||
| 1814 | { | ||
| 1815 | static assert(is(typeof(v) : size_t), typeof(v).stringof); | ||
| 1816 | blackouts[i].pos = v; | ||
| 1817 | blackouts[i].len = 1; | ||
| 1818 | } | ||
| 1819 | static if (i > 0) | ||
| 1820 | { | ||
| 1821 | import std.exception : enforce; | ||
| 1822 | |||
| 1823 | enforce(blackouts[i - 1].pos + blackouts[i - 1].len | ||
| 1824 | <= blackouts[i].pos, | ||
| 1825 | "remove(): incorrect ordering of elements to remove"); | ||
| 1826 | } | ||
| 1827 | } | ||
| 1828 | |||
| 1829 | size_t left = 0, right = offset.length - 1; | ||
| 1830 | auto tgt = range.save; | ||
| 1831 | size_t tgtPos = 0; | ||
| 1832 | |||
| 1833 | while (left <= right) | ||
| 1834 | { | ||
| 1835 | // Look for a blackout on the right | ||
| 1836 | if (blackouts[right].pos + blackouts[right].len >= range.length) | ||
| 1837 | { | ||
| 1838 | range.popBackExactly(blackouts[right].len); | ||
| 1839 | |||
| 1840 | // Since right is unsigned, we must check for this case, otherwise | ||
| 1841 | // we might turn it into size_t.max and the loop condition will not | ||
| 1842 | // fail when it should. | ||
| 1843 | if (right > 0) | ||
| 1844 | { | ||
| 1845 | --right; | ||
| 1846 | continue; | ||
| 1847 | } | ||
| 1848 | else | ||
| 1849 | break; | ||
| 1850 | } | ||
| 1851 | // Advance to next blackout on the left | ||
| 1852 | assert(blackouts[left].pos >= tgtPos); | ||
| 1853 | tgt.popFrontExactly(blackouts[left].pos - tgtPos); | ||
| 1854 | tgtPos = blackouts[left].pos; | ||
| 1855 | |||
| 1856 | // Number of elements to the right of blackouts[right] | ||
| 1857 | immutable tailLen = range.length - (blackouts[right].pos + blackouts[right].len); | ||
| 1858 | size_t toMove = void; | ||
| 1859 | if (tailLen < blackouts[left].len) | ||
| 1860 | { | ||
| 1861 | toMove = tailLen; | ||
| 1862 | blackouts[left].pos += toMove; | ||
| 1863 | blackouts[left].len -= toMove; | ||
| 1864 | } | ||
| 1865 | else | ||
| 1866 | { | ||
| 1867 | toMove = blackouts[left].len; | ||
| 1868 | ++left; | ||
| 1869 | } | ||
| 1870 | tgtPos += toMove; | ||
| 1871 | foreach (i; 0 .. toMove) | ||
| 1872 | { | ||
| 1873 | move(range.back, tgt.front); | ||
| 1874 | range.popBack(); | ||
| 1875 | tgt.popFront(); | ||
| 1876 | } | ||
| 1877 | } | ||
| 1878 | |||
| 1879 | return range; | ||
| 1880 | } | ||
| 1881 | |||
| 1882 | /// Ditto | ||
| 1883 | Range remove | ||
| 1884 | (SwapStrategy s = SwapStrategy.stable, Range, Offset...) | ||
| 1885 | (Range range, Offset offset) | ||
| 1886 | if (s == SwapStrategy.stable | ||
| 1887 | && isBidirectionalRange!Range | ||
| 1888 | && hasLvalueElements!Range | ||
| 1889 | && Offset.length >= 1) | ||
| 1890 | { | ||
| 1891 | auto result = range; | ||
| 1892 | auto src = range, tgt = range; | ||
| 1893 | size_t pos; | ||
| 1894 | foreach (pass, i; offset) | ||
| 1895 | { | ||
| 1896 | static if (is(typeof(i[0])) && is(typeof(i[1]))) | ||
| 1897 | { | ||
| 1898 | auto from = i[0], delta = i[1] - i[0]; | ||
| 1899 | } | ||
| 1900 | else | ||
| 1901 | { | ||
| 1902 | auto from = i; | ||
| 1903 | enum delta = 1; | ||
| 1904 | } | ||
| 1905 | |||
| 1906 | static if (pass > 0) | ||
| 1907 | { | ||
| 1908 | import std.exception : enforce; | ||
| 1909 | enforce(pos <= from, | ||
| 1910 | "remove(): incorrect ordering of elements to remove"); | ||
| 1911 | |||
| 1912 | for (; pos < from; ++pos, src.popFront(), tgt.popFront()) | ||
| 1913 | { | ||
| 1914 | move(src.front, tgt.front); | ||
| 1915 | } | ||
| 1916 | } | ||
| 1917 | else | ||
| 1918 | { | ||
| 1919 | src.popFrontExactly(from); | ||
| 1920 | tgt.popFrontExactly(from); | ||
| 1921 | pos = from; | ||
| 1922 | } | ||
| 1923 | // now skip source to the "to" position | ||
| 1924 | src.popFrontExactly(delta); | ||
| 1925 | result.popBackExactly(delta); | ||
| 1926 | pos += delta; | ||
| 1927 | } | ||
| 1928 | // leftover move | ||
| 1929 | moveAll(src, tgt); | ||
| 1930 | return result; | ||
| 1931 | } | ||
| 1932 | |||
| 1933 | /// | ||
| 1934 | @safe pure unittest | ||
| 1935 | { | ||
| 1936 | import std.typecons : tuple; | ||
| 1937 | |||
| 1938 | auto a = [ 0, 1, 2, 3, 4, 5 ]; | ||
| 1939 | assert(remove!(SwapStrategy.stable)(a, 1) == [ 0, 2, 3, 4, 5 ]); | ||
| 1940 | a = [ 0, 1, 2, 3, 4, 5 ]; | ||
| 1941 | assert(remove!(SwapStrategy.stable)(a, 1, 3) == [ 0, 2, 4, 5] ); | ||
| 1942 | a = [ 0, 1, 2, 3, 4, 5 ]; | ||
| 1943 | assert(remove!(SwapStrategy.stable)(a, 1, tuple(3, 6)) == [ 0, 2 ]); | ||
| 1944 | |||
| 1945 | a = [ 0, 1, 2, 3, 4, 5 ]; | ||
| 1946 | assert(remove!(SwapStrategy.unstable)(a, 1) == [0, 5, 2, 3, 4]); | ||
| 1947 | a = [ 0, 1, 2, 3, 4, 5 ]; | ||
| 1948 | assert(remove!(SwapStrategy.unstable)(a, tuple(1, 4)) == [0, 5, 4]); | ||
| 1949 | } | ||
| 1950 | |||
| 1951 | @safe unittest | ||
| 1952 | { | ||
| 1953 | import std.exception : assertThrown; | ||
| 1954 | import std.range; | ||
| 1955 | |||
| 1956 | // http://d.puremagic.com/issues/show_bug.cgi?id=10173 | ||
| 1957 | int[] test = iota(0, 10).array(); | ||
| 1958 | assertThrown(remove!(SwapStrategy.stable)(test, tuple(2, 4), tuple(1, 3))); | ||
| 1959 | assertThrown(remove!(SwapStrategy.unstable)(test, tuple(2, 4), tuple(1, 3))); | ||
| 1960 | assertThrown(remove!(SwapStrategy.stable)(test, 2, 4, 1, 3)); | ||
| 1961 | assertThrown(remove!(SwapStrategy.unstable)(test, 2, 4, 1, 3)); | ||
| 1962 | } | ||
| 1963 | |||
| 1964 | @safe unittest | ||
| 1965 | { | ||
| 1966 | import std.range; | ||
| 1967 | int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1968 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1969 | assert(remove!(SwapStrategy.stable)(a, 1) == | ||
| 1970 | [ 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]); | ||
| 1971 | |||
| 1972 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1973 | assert(remove!(SwapStrategy.unstable)(a, 0, 10) == | ||
| 1974 | [ 9, 1, 2, 3, 4, 5, 6, 7, 8 ]); | ||
| 1975 | |||
| 1976 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1977 | assert(remove!(SwapStrategy.unstable)(a, 0, tuple(9, 11)) == | ||
| 1978 | [ 8, 1, 2, 3, 4, 5, 6, 7 ]); | ||
| 1979 | // http://d.puremagic.com/issues/show_bug.cgi?id=5224 | ||
| 1980 | a = [ 1, 2, 3, 4 ]; | ||
| 1981 | assert(remove!(SwapStrategy.unstable)(a, 2) == | ||
| 1982 | [ 1, 2, 4 ]); | ||
| 1983 | |||
| 1984 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1985 | assert(remove!(SwapStrategy.stable)(a, 1, 5) == | ||
| 1986 | [ 0, 2, 3, 4, 6, 7, 8, 9, 10 ]); | ||
| 1987 | |||
| 1988 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1989 | assert(remove!(SwapStrategy.stable)(a, 1, 3, 5) | ||
| 1990 | == [ 0, 2, 4, 6, 7, 8, 9, 10]); | ||
| 1991 | a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; | ||
| 1992 | assert(remove!(SwapStrategy.stable)(a, 1, tuple(3, 5)) | ||
| 1993 | == [ 0, 2, 5, 6, 7, 8, 9, 10]); | ||
| 1994 | |||
| 1995 | a = iota(0, 10).array(); | ||
| 1996 | assert(remove!(SwapStrategy.unstable)(a, tuple(1, 4), tuple(6, 7)) | ||
| 1997 | == [0, 9, 8, 7, 4, 5]); | ||
| 1998 | } | ||
| 1999 | |||
| 2000 | @safe unittest | ||
| 2001 | { | ||
| 2002 | // Issue 11576 | ||
| 2003 | auto arr = [1,2,3]; | ||
| 2004 | arr = arr.remove!(SwapStrategy.unstable)(2); | ||
| 2005 | assert(arr == [1,2]); | ||
| 2006 | |||
| 2007 | } | ||
| 2008 | |||
| 2009 | @safe unittest | ||
| 2010 | { | ||
| 2011 | import std.range; | ||
| 2012 | // Bug# 12889 | ||
| 2013 | int[1][] arr = [[0], [1], [2], [3], [4], [5], [6]]; | ||
| 2014 | auto orig = arr.dup; | ||
| 2015 | foreach (i; iota(arr.length)) | ||
| 2016 | { | ||
| 2017 | assert(orig == arr.remove!(SwapStrategy.unstable)(tuple(i,i))); | ||
| 2018 | assert(orig == arr.remove!(SwapStrategy.stable)(tuple(i,i))); | ||
| 2019 | } | ||
| 2020 | } | ||
| 2021 | |||
| 2022 | /** | ||
| 2023 | Reduces the length of the | ||
| 2024 | $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,_range,primitives) $(D range) by removing | ||
| 2025 | elements that satisfy $(D pred). If $(D s = SwapStrategy.unstable), | ||
| 2026 | elements are moved from the right end of the range over the elements | ||
| 2027 | to eliminate. If $(D s = SwapStrategy.stable) (the default), | ||
| 2028 | elements are moved progressively to front such that their relative | ||
| 2029 | order is preserved. Returns the filtered range. | ||
| 2030 | |||
| 2031 | Params: | ||
| 2032 | range = a bidirectional ranges with lvalue elements | ||
| 2033 | |||
| 2034 | Returns: | ||
| 2035 | the range with all of the elements where $(D pred) is $(D true) | ||
| 2036 | removed | ||
| 2037 | */ | ||
| 2038 | Range remove(alias pred, SwapStrategy s = SwapStrategy.stable, Range) | ||
| 2039 | (Range range) | ||
| 2040 | if (isBidirectionalRange!Range | ||
| 2041 | && hasLvalueElements!Range) | ||
| 2042 | { | ||
| 2043 | import std.functional : unaryFun; | ||
| 2044 | auto result = range; | ||
| 2045 | static if (s != SwapStrategy.stable) | ||
| 2046 | { | ||
| 2047 | for (;!range.empty;) | ||
| 2048 | { | ||
| 2049 | if (!unaryFun!pred(range.front)) | ||
| 2050 | { | ||
| 2051 | range.popFront(); | ||
| 2052 | continue; | ||
| 2053 | } | ||
| 2054 | move(range.back, range.front); | ||
| 2055 | range.popBack(); | ||
| 2056 | result.popBack(); | ||
| 2057 | } | ||
| 2058 | } | ||
| 2059 | else | ||
| 2060 | { | ||
| 2061 | auto tgt = range; | ||
| 2062 | for (; !range.empty; range.popFront()) | ||
| 2063 | { | ||
| 2064 | if (unaryFun!(pred)(range.front)) | ||
| 2065 | { | ||
| 2066 | // yank this guy | ||
| 2067 | result.popBack(); | ||
| 2068 | continue; | ||
| 2069 | } | ||
| 2070 | // keep this guy | ||
| 2071 | move(range.front, tgt.front); | ||
| 2072 | tgt.popFront(); | ||
| 2073 | } | ||
| 2074 | } | ||
| 2075 | return result; | ||
| 2076 | } | ||
| 2077 | |||
| 2078 | /// | ||
| 2079 | @safe unittest | ||
| 2080 | { | ||
| 2081 | static immutable base = [1, 2, 3, 2, 4, 2, 5, 2]; | ||
| 2082 | |||
| 2083 | int[] arr = base[].dup; | ||
| 2084 | |||
| 2085 | // using a string-based predicate | ||
| 2086 | assert(remove!("a == 2")(arr) == [ 1, 3, 4, 5 ]); | ||
| 2087 | |||
| 2088 | // The original array contents have been modified, | ||
| 2089 | // so we need to reset it to its original state. | ||
| 2090 | // The length is unmodified however. | ||
| 2091 | arr[] = base[]; | ||
| 2092 | |||
| 2093 | // using a lambda predicate | ||
| 2094 | assert(remove!(a => a == 2)(arr) == [ 1, 3, 4, 5 ]); | ||
| 2095 | } | ||
| 2096 | |||
| 2097 | @safe unittest | ||
| 2098 | { | ||
| 2099 | int[] a = [ 1, 2, 3, 2, 3, 4, 5, 2, 5, 6 ]; | ||
| 2100 | assert(remove!("a == 2", SwapStrategy.unstable)(a) == | ||
| 2101 | [ 1, 6, 3, 5, 3, 4, 5 ]); | ||
| 2102 | a = [ 1, 2, 3, 2, 3, 4, 5, 2, 5, 6 ]; | ||
| 2103 | assert(remove!("a == 2", SwapStrategy.stable)(a) == | ||
| 2104 | [ 1, 3, 3, 4, 5, 5, 6 ]); | ||
| 2105 | } | ||
| 2106 | |||
| 2107 | @nogc @system unittest | ||
| 2108 | { | ||
| 2109 | // @nogc test | ||
| 2110 | int[10] arr = [0,1,2,3,4,5,6,7,8,9]; | ||
| 2111 | alias pred = e => e < 5; | ||
| 2112 | |||
| 2113 | auto r = arr[].remove!(SwapStrategy.unstable)(0); | ||
| 2114 | r = r.remove!(SwapStrategy.stable)(0); | ||
| 2115 | r = r.remove!(pred, SwapStrategy.unstable); | ||
| 2116 | r = r.remove!(pred, SwapStrategy.stable); | ||
| 2117 | } | ||
| 2118 | |||
| 2119 | @safe unittest | ||
| 2120 | { | ||
| 2121 | import std.algorithm.comparison : min; | ||
| 2122 | import std.algorithm.searching : all, any; | ||
| 2123 | import std.algorithm.sorting : isStrictlyMonotonic; | ||
| 2124 | import std.array : array; | ||
| 2125 | import std.meta : AliasSeq; | ||
| 2126 | import std.range : iota, only; | ||
| 2127 | import std.typecons : Tuple; | ||
| 2128 | alias S = Tuple!(int[2]); | ||
| 2129 | S[] soffsets; | ||
| 2130 | foreach (start; 0 .. 5) | ||
| 2131 | foreach (end; min(start+1,5) .. 5) | ||
| 2132 | soffsets ~= S([start,end]); | ||
| 2133 | alias D = Tuple!(int[2],int[2]); | ||
| 2134 | D[] doffsets; | ||
| 2135 | foreach (start1; 0 .. 10) | ||
| 2136 | foreach (end1; min(start1+1,10) .. 10) | ||
| 2137 | foreach (start2; end1 .. 10) | ||
| 2138 | foreach (end2; min(start2+1,10) .. 10) | ||
| 2139 | doffsets ~= D([start1,end1],[start2,end2]); | ||
| 2140 | alias T = Tuple!(int[2],int[2],int[2]); | ||
| 2141 | T[] toffsets; | ||
| 2142 | foreach (start1; 0 .. 15) | ||
| 2143 | foreach (end1; min(start1+1,15) .. 15) | ||
| 2144 | foreach (start2; end1 .. 15) | ||
| 2145 | foreach (end2; min(start2+1,15) .. 15) | ||
| 2146 | foreach (start3; end2 .. 15) | ||
| 2147 | foreach (end3; min(start3+1,15) .. 15) | ||
| 2148 | toffsets ~= T([start1,end1],[start2,end2],[start3,end3]); | ||
| 2149 | |||
| 2150 | static void verify(O...)(int[] r, int len, int removed, bool stable, O offsets) | ||
| 2151 | { | ||
| 2152 | assert(r.length == len - removed); | ||
| 2153 | assert(!stable || r.isStrictlyMonotonic); | ||
| 2154 | assert(r.all!(e => all!(o => e < o[0] || e >= o[1])(offsets.only))); | ||
| 2155 | } | ||
| 2156 | |||
| 2157 | foreach (offsets; AliasSeq!(soffsets,doffsets,toffsets)) | ||
| 2158 | foreach (os; offsets) | ||
| 2159 | { | ||
| 2160 | int len = 5*os.length; | ||
| 2161 | auto w = iota(0, len).array; | ||
| 2162 | auto x = w.dup; | ||
| 2163 | auto y = w.dup; | ||
| 2164 | auto z = w.dup; | ||
| 2165 | alias pred = e => any!(o => o[0] <= e && e < o[1])(only(os.expand)); | ||
| 2166 | w = w.remove!(SwapStrategy.unstable)(os.expand); | ||
| 2167 | x = x.remove!(SwapStrategy.stable)(os.expand); | ||
| 2168 | y = y.remove!(pred, SwapStrategy.unstable); | ||
| 2169 | z = z.remove!(pred, SwapStrategy.stable); | ||
| 2170 | int removed; | ||
| 2171 | foreach (o; os) | ||
| 2172 | removed += o[1] - o[0]; | ||
| 2173 | verify(w, len, removed, false, os[]); | ||
| 2174 | verify(x, len, removed, true, os[]); | ||
| 2175 | verify(y, len, removed, false, os[]); | ||
| 2176 | verify(z, len, removed, true, os[]); | ||
| 2177 | assert(w == y); | ||
| 2178 | assert(x == z); | ||
| 2179 | } | ||
| 2180 | } | ||
| 2181 | |||
| 2182 | // reverse | ||
| 2183 | /** | ||
| 2184 | Reverses $(D r) in-place. Performs $(D r.length / 2) evaluations of $(D | ||
| 2185 | swap). | ||
| 2186 | Params: | ||
| 2187 | r = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,range,primitives) | ||
| 2188 | with swappable elements or a random access range with a length member | ||
| 2189 | |||
| 2190 | See_Also: | ||
| 2191 | $(HTTP sgi.com/tech/stl/_reverse.html, STL's _reverse), $(REF retro, std,range) for a lazy reversed range view | ||
| 2192 | */ | ||
| 2193 | void reverse(Range)(Range r) | ||
| 2194 | if (isBidirectionalRange!Range && !isRandomAccessRange!Range | ||
| 2195 | && hasSwappableElements!Range) | ||
| 2196 | { | ||
| 2197 | while (!r.empty) | ||
| 2198 | { | ||
| 2199 | swap(r.front, r.back); | ||
| 2200 | r.popFront(); | ||
| 2201 | if (r.empty) break; | ||
| 2202 | r.popBack(); | ||
| 2203 | } | ||
| 2204 | } | ||
| 2205 | |||
| 2206 | /// | ||
| 2207 | @safe unittest | ||
| 2208 | { | ||
| 2209 | int[] arr = [ 1, 2, 3 ]; | ||
| 2210 | reverse(arr); | ||
| 2211 | assert(arr == [ 3, 2, 1 ]); | ||
| 2212 | } | ||
| 2213 | |||
| 2214 | ///ditto | ||
| 2215 | void reverse(Range)(Range r) | ||
| 2216 | if (isRandomAccessRange!Range && hasLength!Range) | ||
| 2217 | { | ||
| 2218 | //swapAt is in fact the only way to swap non lvalue ranges | ||
| 2219 | immutable last = r.length-1; | ||
| 2220 | immutable steps = r.length/2; | ||
| 2221 | for (size_t i = 0; i < steps; i++) | ||
| 2222 | { | ||
| 2223 | r.swapAt(i, last-i); | ||
| 2224 | } | ||
| 2225 | } | ||
| 2226 | |||
| 2227 | @safe unittest | ||
| 2228 | { | ||
| 2229 | int[] range = null; | ||
| 2230 | reverse(range); | ||
| 2231 | range = [ 1 ]; | ||
| 2232 | reverse(range); | ||
| 2233 | assert(range == [1]); | ||
| 2234 | range = [1, 2]; | ||
| 2235 | reverse(range); | ||
| 2236 | assert(range == [2, 1]); | ||
| 2237 | range = [1, 2, 3]; | ||
| 2238 | reverse(range); | ||
| 2239 | assert(range == [3, 2, 1]); | ||
| 2240 | } | ||
| 2241 | |||
| 2242 | /** | ||
| 2243 | Reverses $(D r) in-place, where $(D r) is a narrow string (having | ||
| 2244 | elements of type $(D char) or $(D wchar)). UTF sequences consisting of | ||
| 2245 | multiple code units are preserved properly. | ||
| 2246 | |||
| 2247 | Params: | ||
| 2248 | s = a narrow string | ||
| 2249 | |||
| 2250 | Bugs: | ||
| 2251 | When passing a sting with unicode modifiers on characters, such as $(D \u0301), | ||
| 2252 | this function will not properly keep the position of the modifier. For example, | ||
| 2253 | reversing $(D ba\u0301d) ("bád") will result in d\u0301ab ("d́ab") instead of | ||
| 2254 | $(D da\u0301b) ("dáb"). | ||
| 2255 | */ | ||
| 2256 | void reverse(Char)(Char[] s) | ||
| 2257 | if (isNarrowString!(Char[]) && !is(Char == const) && !is(Char == immutable)) | ||
| 2258 | { | ||
| 2259 | import std.string : representation; | ||
| 2260 | import std.utf : stride; | ||
| 2261 | |||
| 2262 | auto r = representation(s); | ||
| 2263 | for (size_t i = 0; i < s.length; ) | ||
| 2264 | { | ||
| 2265 | immutable step = stride(s, i); | ||
| 2266 | if (step > 1) | ||
| 2267 | { | ||
| 2268 | .reverse(r[i .. i + step]); | ||
| 2269 | i += step; | ||
| 2270 | } | ||
| 2271 | else | ||
| 2272 | { | ||
| 2273 | ++i; | ||
| 2274 | } | ||
| 2275 | } | ||
| 2276 | reverse(r); | ||
| 2277 | } | ||
| 2278 | |||
| 2279 | /// | ||
| 2280 | @safe unittest | ||
| 2281 | { | ||
| 2282 | char[] arr = "hello\U00010143\u0100\U00010143".dup; | ||
| 2283 | reverse(arr); | ||
| 2284 | assert(arr == "\U00010143\u0100\U00010143olleh"); | ||
| 2285 | } | ||
| 2286 | |||
| 2287 | @safe unittest | ||
| 2288 | { | ||
| 2289 | void test(string a, string b) | ||
| 2290 | { | ||
| 2291 | auto c = a.dup; | ||
| 2292 | reverse(c); | ||
| 2293 | assert(c == b, c ~ " != " ~ b); | ||
| 2294 | } | ||
| 2295 | |||
| 2296 | test("a", "a"); | ||
| 2297 | test(" ", " "); | ||
| 2298 | test("\u2029", "\u2029"); | ||
| 2299 | test("\u0100", "\u0100"); | ||
| 2300 | test("\u0430", "\u0430"); | ||
| 2301 | test("\U00010143", "\U00010143"); | ||
| 2302 | test("abcdefcdef", "fedcfedcba"); | ||
| 2303 | test("hello\U00010143\u0100\U00010143", "\U00010143\u0100\U00010143olleh"); | ||
| 2304 | } | ||
| 2305 | |||
| 2306 | /** | ||
| 2307 | The strip group of functions allow stripping of either leading, trailing, | ||
| 2308 | or both leading and trailing elements. | ||
| 2309 | |||
| 2310 | The $(D stripLeft) function will strip the $(D front) of the range, | ||
| 2311 | the $(D stripRight) function will strip the $(D back) of the range, | ||
| 2312 | while the $(D strip) function will strip both the $(D front) and $(D back) | ||
| 2313 | of the range. | ||
| 2314 | |||
| 2315 | Note that the $(D strip) and $(D stripRight) functions require the range to | ||
| 2316 | be a $(LREF BidirectionalRange) range. | ||
| 2317 | |||
| 2318 | All of these functions come in two varieties: one takes a target element, | ||
| 2319 | where the range will be stripped as long as this element can be found. | ||
| 2320 | The other takes a lambda predicate, where the range will be stripped as | ||
| 2321 | long as the predicate returns true. | ||
| 2322 | |||
| 2323 | Params: | ||
| 2324 | range = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,range,primitives) | ||
| 2325 | or $(REF_ALTTEXT input range, isInputRange, std,range,primitives) | ||
| 2326 | element = the elements to remove | ||
| 2327 | |||
| 2328 | Returns: | ||
| 2329 | a Range with all of range except element at the start and end | ||
| 2330 | */ | ||
| 2331 | Range strip(Range, E)(Range range, E element) | ||
| 2332 | if (isBidirectionalRange!Range && is(typeof(range.front == element) : bool)) | ||
| 2333 | { | ||
| 2334 | return range.stripLeft(element).stripRight(element); | ||
| 2335 | } | ||
| 2336 | |||
| 2337 | /// ditto | ||
| 2338 | Range strip(alias pred, Range)(Range range) | ||
| 2339 | if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool)) | ||
| 2340 | { | ||
| 2341 | return range.stripLeft!pred().stripRight!pred(); | ||
| 2342 | } | ||
| 2343 | |||
| 2344 | /// ditto | ||
| 2345 | Range stripLeft(Range, E)(Range range, E element) | ||
| 2346 | if (isInputRange!Range && is(typeof(range.front == element) : bool)) | ||
| 2347 | { | ||
| 2348 | import std.algorithm.searching : find; | ||
| 2349 | return find!((auto ref a) => a != element)(range); | ||
| 2350 | } | ||
| 2351 | |||
| 2352 | /// ditto | ||
| 2353 | Range stripLeft(alias pred, Range)(Range range) | ||
| 2354 | if (isInputRange!Range && is(typeof(pred(range.front)) : bool)) | ||
| 2355 | { | ||
| 2356 | import std.algorithm.searching : find; | ||
| 2357 | import std.functional : not; | ||
| 2358 | |||
| 2359 | return find!(not!pred)(range); | ||
| 2360 | } | ||
| 2361 | |||
| 2362 | /// ditto | ||
| 2363 | Range stripRight(Range, E)(Range range, E element) | ||
| 2364 | if (isBidirectionalRange!Range && is(typeof(range.back == element) : bool)) | ||
| 2365 | { | ||
| 2366 | for (; !range.empty; range.popBack()) | ||
| 2367 | { | ||
| 2368 | if (range.back != element) | ||
| 2369 | break; | ||
| 2370 | } | ||
| 2371 | return range; | ||
| 2372 | } | ||
| 2373 | |||
| 2374 | /// ditto | ||
| 2375 | Range stripRight(alias pred, Range)(Range range) | ||
| 2376 | if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool)) | ||
| 2377 | { | ||
| 2378 | for (; !range.empty; range.popBack()) | ||
| 2379 | { | ||
| 2380 | if (!pred(range.back)) | ||
| 2381 | break; | ||
| 2382 | } | ||
| 2383 | return range; | ||
| 2384 | } | ||
| 2385 | |||
| 2386 | /// Strip leading and trailing elements equal to the target element. | ||
| 2387 | @safe pure unittest | ||
| 2388 | { | ||
| 2389 | assert(" foobar ".strip(' ') == "foobar"); | ||
| 2390 | assert("00223.444500".strip('0') == "223.4445"); | ||
| 2391 | assert("ëëêéüŗōpéêëë".strip('ë') == "êéüŗōpéê"); | ||
| 2392 | assert([1, 1, 0, 1, 1].strip(1) == [0]); | ||
| 2393 | assert([0.0, 0.01, 0.01, 0.0].strip(0).length == 2); | ||
| 2394 | } | ||
| 2395 | |||
| 2396 | /// Strip leading and trailing elements while the predicate returns true. | ||
| 2397 | @safe pure unittest | ||
| 2398 | { | ||
| 2399 | assert(" foobar ".strip!(a => a == ' ')() == "foobar"); | ||
| 2400 | assert("00223.444500".strip!(a => a == '0')() == "223.4445"); | ||
| 2401 | assert("ëëêéüŗōpéêëë".strip!(a => a == 'ë')() == "êéüŗōpéê"); | ||
| 2402 | assert([1, 1, 0, 1, 1].strip!(a => a == 1)() == [0]); | ||
| 2403 | assert([0.0, 0.01, 0.5, 0.6, 0.01, 0.0].strip!(a => a < 0.4)().length == 2); | ||
| 2404 | } | ||
| 2405 | |||
| 2406 | /// Strip leading elements equal to the target element. | ||
| 2407 | @safe pure unittest | ||
| 2408 | { | ||
| 2409 | assert(" foobar ".stripLeft(' ') == "foobar "); | ||
| 2410 | assert("00223.444500".stripLeft('0') == "223.444500"); | ||
| 2411 | assert("ůůűniçodêéé".stripLeft('ů') == "űniçodêéé"); | ||
| 2412 | assert([1, 1, 0, 1, 1].stripLeft(1) == [0, 1, 1]); | ||
| 2413 | assert([0.0, 0.01, 0.01, 0.0].stripLeft(0).length == 3); | ||
| 2414 | } | ||
| 2415 | |||
| 2416 | /// Strip leading elements while the predicate returns true. | ||
| 2417 | @safe pure unittest | ||
| 2418 | { | ||
| 2419 | assert(" foobar ".stripLeft!(a => a == ' ')() == "foobar "); | ||
| 2420 | assert("00223.444500".stripLeft!(a => a == '0')() == "223.444500"); | ||
| 2421 | assert("ůůűniçodêéé".stripLeft!(a => a == 'ů')() == "űniçodêéé"); | ||
| 2422 | assert([1, 1, 0, 1, 1].stripLeft!(a => a == 1)() == [0, 1, 1]); | ||
| 2423 | assert([0.0, 0.01, 0.10, 0.5, 0.6].stripLeft!(a => a < 0.4)().length == 2); | ||
| 2424 | } | ||
| 2425 | |||
| 2426 | /// Strip trailing elements equal to the target element. | ||
| 2427 | @safe pure unittest | ||
| 2428 | { | ||
| 2429 | assert(" foobar ".stripRight(' ') == " foobar"); | ||
| 2430 | assert("00223.444500".stripRight('0') == "00223.4445"); | ||
| 2431 | assert("ùniçodêéé".stripRight('é') == "ùniçodê"); | ||
| 2432 | assert([1, 1, 0, 1, 1].stripRight(1) == [1, 1, 0]); | ||
| 2433 | assert([0.0, 0.01, 0.01, 0.0].stripRight(0).length == 3); | ||
| 2434 | } | ||
| 2435 | |||
| 2436 | /// Strip trailing elements while the predicate returns true. | ||
| 2437 | @safe pure unittest | ||
| 2438 | { | ||
| 2439 | assert(" foobar ".stripRight!(a => a == ' ')() == " foobar"); | ||
| 2440 | assert("00223.444500".stripRight!(a => a == '0')() == "00223.4445"); | ||
| 2441 | assert("ùniçodêéé".stripRight!(a => a == 'é')() == "ùniçodê"); | ||
| 2442 | assert([1, 1, 0, 1, 1].stripRight!(a => a == 1)() == [1, 1, 0]); | ||
| 2443 | assert([0.0, 0.01, 0.10, 0.5, 0.6].stripRight!(a => a > 0.4)().length == 3); | ||
| 2444 | } | ||
| 2445 | |||
| 2446 | // swap | ||
| 2447 | /** | ||
| 2448 | Swaps $(D lhs) and $(D rhs). The instances $(D lhs) and $(D rhs) are moved in | ||
| 2449 | memory, without ever calling $(D opAssign), nor any other function. $(D T) | ||
| 2450 | need not be assignable at all to be swapped. | ||
| 2451 | |||
| 2452 | If $(D lhs) and $(D rhs) reference the same instance, then nothing is done. | ||
| 2453 | |||
| 2454 | $(D lhs) and $(D rhs) must be mutable. If $(D T) is a struct or union, then | ||
| 2455 | its fields must also all be (recursively) mutable. | ||
| 2456 | |||
| 2457 | Params: | ||
| 2458 | lhs = Data to be swapped with $(D rhs). | ||
| 2459 | rhs = Data to be swapped with $(D lhs). | ||
| 2460 | */ | ||
| 2461 | void swap(T)(ref T lhs, ref T rhs) @trusted pure nothrow @nogc | ||
| 2462 | if (isBlitAssignable!T && !is(typeof(lhs.proxySwap(rhs)))) | ||
| 2463 | { | ||
| 2464 | import std.traits : hasAliasing, hasElaborateAssign, isAssignable, | ||
| 2465 | isStaticArray; | ||
| 2466 | static if (hasAliasing!T) if (!__ctfe) | ||
| 2467 | { | ||
| 2468 | import std.exception : doesPointTo; | ||
| 2469 | assert(!doesPointTo(lhs, lhs), "Swap: lhs internal pointer."); | ||
| 2470 | assert(!doesPointTo(rhs, rhs), "Swap: rhs internal pointer."); | ||
| 2471 | assert(!doesPointTo(lhs, rhs), "Swap: lhs points to rhs."); | ||
| 2472 | assert(!doesPointTo(rhs, lhs), "Swap: rhs points to lhs."); | ||
| 2473 | } | ||
| 2474 | |||
| 2475 | static if (hasElaborateAssign!T || !isAssignable!T) | ||
| 2476 | { | ||
| 2477 | if (&lhs != &rhs) | ||
| 2478 | { | ||
| 2479 | // For structs with non-trivial assignment, move memory directly | ||
| 2480 | ubyte[T.sizeof] t = void; | ||
| 2481 | auto a = (cast(ubyte*) &lhs)[0 .. T.sizeof]; | ||
| 2482 | auto b = (cast(ubyte*) &rhs)[0 .. T.sizeof]; | ||
| 2483 | t[] = a[]; | ||
| 2484 | a[] = b[]; | ||
| 2485 | b[] = t[]; | ||
| 2486 | } | ||
| 2487 | } | ||
| 2488 | else | ||
| 2489 | { | ||
| 2490 | //Avoid assigning overlapping arrays. Dynamic arrays are fine, because | ||
| 2491 | //it's their ptr and length properties which get assigned rather | ||
| 2492 | //than their elements when assigning them, but static arrays are value | ||
| 2493 | //types and therefore all of their elements get copied as part of | ||
| 2494 | //assigning them, which would be assigning overlapping arrays if lhs | ||
| 2495 | //and rhs were the same array. | ||
| 2496 | static if (isStaticArray!T) | ||
| 2497 | { | ||
| 2498 | if (lhs.ptr == rhs.ptr) | ||
| 2499 | return; | ||
| 2500 | } | ||
| 2501 | |||
| 2502 | // For non-struct types, suffice to do the classic swap | ||
| 2503 | auto tmp = lhs; | ||
| 2504 | lhs = rhs; | ||
| 2505 | rhs = tmp; | ||
| 2506 | } | ||
| 2507 | } | ||
| 2508 | |||
| 2509 | /// | ||
| 2510 | @safe unittest | ||
| 2511 | { | ||
| 2512 | // Swapping POD (plain old data) types: | ||
| 2513 | int a = 42, b = 34; | ||
| 2514 | swap(a, b); | ||
| 2515 | assert(a == 34 && b == 42); | ||
| 2516 | |||
| 2517 | // Swapping structs with indirection: | ||
| 2518 | static struct S { int x; char c; int[] y; } | ||
| 2519 | S s1 = { 0, 'z', [ 1, 2 ] }; | ||
| 2520 | S s2 = { 42, 'a', [ 4, 6 ] }; | ||
| 2521 | swap(s1, s2); | ||
| 2522 | assert(s1.x == 42); | ||
| 2523 | assert(s1.c == 'a'); | ||
| 2524 | assert(s1.y == [ 4, 6 ]); | ||
| 2525 | |||
| 2526 | assert(s2.x == 0); | ||
| 2527 | assert(s2.c == 'z'); | ||
| 2528 | assert(s2.y == [ 1, 2 ]); | ||
| 2529 | |||
| 2530 | // Immutables cannot be swapped: | ||
| 2531 | immutable int imm1 = 1, imm2 = 2; | ||
| 2532 | static assert(!__traits(compiles, swap(imm1, imm2))); | ||
| 2533 | |||
| 2534 | int c = imm1 + 0; | ||
| 2535 | int d = imm2 + 0; | ||
| 2536 | swap(c, d); | ||
| 2537 | assert(c == 2); | ||
| 2538 | assert(d == 1); | ||
| 2539 | } | ||
| 2540 | |||
| 2541 | /// | ||
| 2542 | @safe unittest | ||
| 2543 | { | ||
| 2544 | // Non-copyable types can still be swapped. | ||
| 2545 | static struct NoCopy | ||
| 2546 | { | ||
| 2547 | this(this) { assert(0); } | ||
| 2548 | int n; | ||
| 2549 | string s; | ||
| 2550 | } | ||
| 2551 | NoCopy nc1, nc2; | ||
| 2552 | nc1.n = 127; nc1.s = "abc"; | ||
| 2553 | nc2.n = 513; nc2.s = "uvwxyz"; | ||
| 2554 | |||
| 2555 | swap(nc1, nc2); | ||
| 2556 | assert(nc1.n == 513 && nc1.s == "uvwxyz"); | ||
| 2557 | assert(nc2.n == 127 && nc2.s == "abc"); | ||
| 2558 | |||
| 2559 | swap(nc1, nc1); | ||
| 2560 | swap(nc2, nc2); | ||
| 2561 | assert(nc1.n == 513 && nc1.s == "uvwxyz"); | ||
| 2562 | assert(nc2.n == 127 && nc2.s == "abc"); | ||
| 2563 | |||
| 2564 | // Types containing non-copyable fields can also be swapped. | ||
| 2565 | static struct NoCopyHolder | ||
| 2566 | { | ||
| 2567 | NoCopy noCopy; | ||
| 2568 | } | ||
| 2569 | NoCopyHolder h1, h2; | ||
| 2570 | h1.noCopy.n = 31; h1.noCopy.s = "abc"; | ||
| 2571 | h2.noCopy.n = 65; h2.noCopy.s = null; | ||
| 2572 | |||
| 2573 | swap(h1, h2); | ||
| 2574 | assert(h1.noCopy.n == 65 && h1.noCopy.s == null); | ||
| 2575 | assert(h2.noCopy.n == 31 && h2.noCopy.s == "abc"); | ||
| 2576 | |||
| 2577 | swap(h1, h1); | ||
| 2578 | swap(h2, h2); | ||
| 2579 | assert(h1.noCopy.n == 65 && h1.noCopy.s == null); | ||
| 2580 | assert(h2.noCopy.n == 31 && h2.noCopy.s == "abc"); | ||
| 2581 | |||
| 2582 | // Const types cannot be swapped. | ||
| 2583 | const NoCopy const1, const2; | ||
| 2584 | assert(const1.n == 0 && const2.n == 0); | ||
| 2585 | static assert(!__traits(compiles, swap(const1, const2))); | ||
| 2586 | } | ||
| 2587 | |||
| 2588 | @safe unittest | ||
| 2589 | { | ||
| 2590 | //Bug# 4789 | ||
| 2591 | int[1] s = [1]; | ||
| 2592 | swap(s, s); | ||
| 2593 | |||
| 2594 | int[3] a = [1, 2, 3]; | ||
| 2595 | swap(a[1], a[2]); | ||
| 2596 | assert(a == [1, 3, 2]); | ||
| 2597 | } | ||
| 2598 | |||
| 2599 | @safe unittest | ||
| 2600 | { | ||
| 2601 | static struct NoAssign | ||
| 2602 | { | ||
| 2603 | int i; | ||
| 2604 | void opAssign(NoAssign) @disable; | ||
| 2605 | } | ||
| 2606 | auto s1 = NoAssign(1); | ||
| 2607 | auto s2 = NoAssign(2); | ||
| 2608 | swap(s1, s2); | ||
| 2609 | assert(s1.i == 2); | ||
| 2610 | assert(s2.i == 1); | ||
| 2611 | } | ||
| 2612 | |||
| 2613 | @safe unittest | ||
| 2614 | { | ||
| 2615 | struct S | ||
| 2616 | { | ||
| 2617 | const int i; | ||
| 2618 | int i2 = 2; | ||
| 2619 | int i3 = 3; | ||
| 2620 | } | ||
| 2621 | S s; | ||
| 2622 | static assert(!__traits(compiles, swap(s, s))); | ||
| 2623 | swap(s.i2, s.i3); | ||
| 2624 | assert(s.i2 == 3); | ||
| 2625 | assert(s.i3 == 2); | ||
| 2626 | } | ||
| 2627 | |||
| 2628 | @safe unittest | ||
| 2629 | { | ||
| 2630 | //11853 | ||
| 2631 | import std.traits : isAssignable; | ||
| 2632 | alias T = Tuple!(int, double); | ||
| 2633 | static assert(isAssignable!T); | ||
| 2634 | } | ||
| 2635 | |||
| 2636 | @safe unittest | ||
| 2637 | { | ||
| 2638 | // 12024 | ||
| 2639 | import std.datetime; | ||
| 2640 | SysTime a, b; | ||
| 2641 | swap(a, b); | ||
| 2642 | } | ||
| 2643 | |||
| 2644 | @system unittest // 9975 | ||
| 2645 | { | ||
| 2646 | import std.exception : doesPointTo, mayPointTo; | ||
| 2647 | static struct S2 | ||
| 2648 | { | ||
| 2649 | union | ||
| 2650 | { | ||
| 2651 | size_t sz; | ||
| 2652 | string s; | ||
| 2653 | } | ||
| 2654 | } | ||
| 2655 | S2 a , b; | ||
| 2656 | a.sz = -1; | ||
| 2657 | assert(!doesPointTo(a, b)); | ||
| 2658 | assert( mayPointTo(a, b)); | ||
| 2659 | swap(a, b); | ||
| 2660 | |||
| 2661 | //Note: we can catch an error here, because there is no RAII in this test | ||
| 2662 | import std.exception : assertThrown; | ||
| 2663 | void* p, pp; | ||
| 2664 | p = &p; | ||
| 2665 | assertThrown!Error(move(p)); | ||
| 2666 | assertThrown!Error(move(p, pp)); | ||
| 2667 | assertThrown!Error(swap(p, pp)); | ||
| 2668 | } | ||
| 2669 | |||
| 2670 | @system unittest | ||
| 2671 | { | ||
| 2672 | static struct A | ||
| 2673 | { | ||
| 2674 | int* x; | ||
| 2675 | this(this) { x = new int; } | ||
| 2676 | } | ||
| 2677 | A a1, a2; | ||
| 2678 | swap(a1, a2); | ||
| 2679 | |||
| 2680 | static struct B | ||
| 2681 | { | ||
| 2682 | int* x; | ||
| 2683 | void opAssign(B) { x = new int; } | ||
| 2684 | } | ||
| 2685 | B b1, b2; | ||
| 2686 | swap(b1, b2); | ||
| 2687 | } | ||
| 2688 | |||
| 2689 | /// ditto | ||
| 2690 | void swap(T)(ref T lhs, ref T rhs) | ||
| 2691 | if (is(typeof(lhs.proxySwap(rhs)))) | ||
| 2692 | { | ||
| 2693 | lhs.proxySwap(rhs); | ||
| 2694 | } | ||
| 2695 | |||
| 2696 | /** | ||
| 2697 | Swaps two elements in-place of a range `r`, | ||
| 2698 | specified by their indices `i1` and `i2`. | ||
| 2699 | |||
| 2700 | Params: | ||
| 2701 | r = a range with swappable elements | ||
| 2702 | i1 = first index | ||
| 2703 | i2 = second index | ||
| 2704 | */ | ||
| 2705 | void swapAt(R)(auto ref R r, size_t i1, size_t i2) | ||
| 2706 | { | ||
| 2707 | static if (is(typeof(&r.swapAt))) | ||
| 2708 | { | ||
| 2709 | r.swapAt(i1, i2); | ||
| 2710 | } | ||
| 2711 | else static if (is(typeof(&r[i1]))) | ||
| 2712 | { | ||
| 2713 | swap(r[i1], r[i2]); | ||
| 2714 | } | ||
| 2715 | else | ||
| 2716 | { | ||
| 2717 | if (i1 == i2) return; | ||
| 2718 | auto t1 = r.moveAt(i1); | ||
| 2719 | auto t2 = r.moveAt(i2); | ||
| 2720 | r[i2] = t1; | ||
| 2721 | r[i1] = t2; | ||
| 2722 | } | ||
| 2723 | } | ||
| 2724 | |||
| 2725 | /// | ||
| 2726 | pure @safe nothrow unittest | ||
| 2727 | { | ||
| 2728 | import std.algorithm.comparison : equal; | ||
| 2729 | auto a = [1, 2, 3]; | ||
| 2730 | a.swapAt(1, 2); | ||
| 2731 | assert(a.equal([1, 3, 2])); | ||
| 2732 | } | ||
| 2733 | |||
| 2734 | pure @safe nothrow unittest | ||
| 2735 | { | ||
| 2736 | import std.algorithm.comparison : equal; | ||
| 2737 | auto a = [4, 5, 6]; | ||
| 2738 | a.swapAt(1, 1); | ||
| 2739 | assert(a.equal([4, 5, 6])); | ||
| 2740 | } | ||
| 2741 | |||
| 2742 | pure @safe nothrow unittest | ||
| 2743 | { | ||
| 2744 | // test non random access ranges | ||
| 2745 | import std.algorithm.comparison : equal; | ||
| 2746 | import std.array : array; | ||
| 2747 | |||
| 2748 | char[] b = ['a', 'b', 'c']; | ||
| 2749 | b.swapAt(1, 2); | ||
| 2750 | assert(b.equal(['a', 'c', 'b'])); | ||
| 2751 | |||
| 2752 | int[3] c = [1, 2, 3]; | ||
| 2753 | c.swapAt(1, 2); | ||
| 2754 | assert(c.array.equal([1, 3, 2])); | ||
| 2755 | |||
| 2756 | // opIndex returns lvalue | ||
| 2757 | struct RandomIndexType(T) | ||
| 2758 | { | ||
| 2759 | T payload; | ||
| 2760 | |||
| 2761 | @property ref auto opIndex(size_t i) | ||
| 2762 | { | ||
| 2763 | return payload[i]; | ||
| 2764 | } | ||
| 2765 | |||
| 2766 | } | ||
| 2767 | auto d = RandomIndexType!(int[])([4, 5, 6]); | ||
| 2768 | d.swapAt(1, 2); | ||
| 2769 | assert(d.payload.equal([4, 6, 5])); | ||
| 2770 | |||
| 2771 | // custom moveAt and opIndexAssign | ||
| 2772 | struct RandomMoveAtType(T) | ||
| 2773 | { | ||
| 2774 | T payload; | ||
| 2775 | |||
| 2776 | ElementType!T moveAt(size_t i) | ||
| 2777 | { | ||
| 2778 | return payload.moveAt(i); | ||
| 2779 | } | ||
| 2780 | |||
| 2781 | void opIndexAssign(ElementType!T val, size_t idx) | ||
| 2782 | { | ||
| 2783 | payload[idx] = val; | ||
| 2784 | } | ||
| 2785 | } | ||
| 2786 | auto e = RandomMoveAtType!(int[])([7, 8, 9]); | ||
| 2787 | e.swapAt(1, 2); | ||
| 2788 | assert(e.payload.equal([7, 9, 8])); | ||
| 2789 | |||
| 2790 | |||
| 2791 | // custom swapAt | ||
| 2792 | struct RandomSwapAtType(T) | ||
| 2793 | { | ||
| 2794 | T payload; | ||
| 2795 | |||
| 2796 | void swapAt(size_t i) | ||
| 2797 | { | ||
| 2798 | return payload.swapAt(i); | ||
| 2799 | } | ||
| 2800 | } | ||
| 2801 | auto f = RandomMoveAtType!(int[])([10, 11, 12]); | ||
| 2802 | swapAt(f, 1, 2); | ||
| 2803 | assert(f.payload.equal([10, 12, 11])); | ||
| 2804 | } | ||
| 2805 | |||
| 2806 | private void swapFront(R1, R2)(R1 r1, R2 r2) | ||
| 2807 | if (isInputRange!R1 && isInputRange!R2) | ||
| 2808 | { | ||
| 2809 | static if (is(typeof(swap(r1.front, r2.front)))) | ||
| 2810 | { | ||
| 2811 | swap(r1.front, r2.front); | ||
| 2812 | } | ||
| 2813 | else | ||
| 2814 | { | ||
| 2815 | auto t1 = moveFront(r1), t2 = moveFront(r2); | ||
| 2816 | r1.front = move(t2); | ||
| 2817 | r2.front = move(t1); | ||
| 2818 | } | ||
| 2819 | } | ||
| 2820 | |||
| 2821 | // swapRanges | ||
| 2822 | /** | ||
| 2823 | Swaps all elements of $(D r1) with successive elements in $(D r2). | ||
| 2824 | Returns a tuple containing the remainder portions of $(D r1) and $(D | ||
| 2825 | r2) that were not swapped (one of them will be empty). The ranges may | ||
| 2826 | be of different types but must have the same element type and support | ||
| 2827 | swapping. | ||
| 2828 | |||
| 2829 | Params: | ||
| 2830 | r1 = an $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 2831 | with swappable elements | ||
| 2832 | r2 = an $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 2833 | with swappable elements | ||
| 2834 | |||
| 2835 | Returns: | ||
| 2836 | Tuple containing the remainder portions of r1 and r2 that were not swapped | ||
| 2837 | */ | ||
| 2838 | Tuple!(InputRange1, InputRange2) | ||
| 2839 | swapRanges(InputRange1, InputRange2)(InputRange1 r1, InputRange2 r2) | ||
| 2840 | if (hasSwappableElements!InputRange1 && hasSwappableElements!InputRange2 | ||
| 2841 | && is(ElementType!InputRange1 == ElementType!InputRange2)) | ||
| 2842 | { | ||
| 2843 | for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront()) | ||
| 2844 | { | ||
| 2845 | swap(r1.front, r2.front); | ||
| 2846 | } | ||
| 2847 | return tuple(r1, r2); | ||
| 2848 | } | ||
| 2849 | |||
| 2850 | /// | ||
| 2851 | @safe unittest | ||
| 2852 | { | ||
| 2853 | import std.range : empty; | ||
| 2854 | int[] a = [ 100, 101, 102, 103 ]; | ||
| 2855 | int[] b = [ 0, 1, 2, 3 ]; | ||
| 2856 | auto c = swapRanges(a[1 .. 3], b[2 .. 4]); | ||
| 2857 | assert(c[0].empty && c[1].empty); | ||
| 2858 | assert(a == [ 100, 2, 3, 103 ]); | ||
| 2859 | assert(b == [ 0, 1, 101, 102 ]); | ||
| 2860 | } | ||
| 2861 | |||
| 2862 | /** | ||
| 2863 | Initializes each element of $(D range) with $(D value). | ||
| 2864 | Assumes that the elements of the range are uninitialized. | ||
| 2865 | This is of interest for structs that | ||
| 2866 | define copy constructors (for all other types, $(LREF fill) and | ||
| 2867 | uninitializedFill are equivalent). | ||
| 2868 | |||
| 2869 | Params: | ||
| 2870 | range = An | ||
| 2871 | $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives) | ||
| 2872 | that exposes references to its elements and has assignable | ||
| 2873 | elements | ||
| 2874 | value = Assigned to each element of range | ||
| 2875 | |||
| 2876 | See_Also: | ||
| 2877 | $(LREF fill) | ||
| 2878 | $(LREF initializeAll) | ||
| 2879 | */ | ||
| 2880 | void uninitializedFill(Range, Value)(Range range, Value value) | ||
| 2881 | if (isInputRange!Range && hasLvalueElements!Range && is(typeof(range.front = value))) | ||
| 2882 | { | ||
| 2883 | import std.traits : hasElaborateAssign; | ||
| 2884 | |||
| 2885 | alias T = ElementType!Range; | ||
| 2886 | static if (hasElaborateAssign!T) | ||
| 2887 | { | ||
| 2888 | import std.conv : emplaceRef; | ||
| 2889 | |||
| 2890 | // Must construct stuff by the book | ||
| 2891 | for (; !range.empty; range.popFront()) | ||
| 2892 | emplaceRef!T(range.front, value); | ||
| 2893 | } | ||
| 2894 | else | ||
| 2895 | // Doesn't matter whether fill is initialized or not | ||
| 2896 | return fill(range, value); | ||
| 2897 | } | ||
| 2898 | |||
| 2899 | /// | ||
| 2900 | nothrow @system unittest | ||
| 2901 | { | ||
| 2902 | import core.stdc.stdlib : malloc, free; | ||
| 2903 | |||
| 2904 | auto s = (cast(int*) malloc(5 * int.sizeof))[0 .. 5]; | ||
| 2905 | uninitializedFill(s, 42); | ||
| 2906 | assert(s == [ 42, 42, 42, 42, 42 ]); | ||
| 2907 | |||
| 2908 | scope(exit) free(s.ptr); | ||
| 2909 | } | ||