Shuffle

[0ffh]

Has it already been proposed to just throw files already
copied out of the list? It's a minimal amendment to the
original (changing one line and adding two):

/* Program to randomly copy music files from source to destination device.
  * Written in the D programming language.
  * Written by Walter Bright, http://www.digitalmars.com
  * Placed into the Public Domain.
  * Minimal amendment by 0ffh to copy any file <= once
  */

import std.file;
import std.stdio;
import std.string;
import std.c.stdlib;
import std.path;
import std.random;

int main(string[] args)
{
     if (args.length != 3)
     {    writefln("Usage: shuffle fromdir todir");
     exit(1);
     }
     auto fromdir = args[1];
     auto todir = args[2];

     /* Recursively search for all the mp3 and wma files in directory fromdir
      * and put them into files[]
      */
     string[] files;
     bool callback(DirEntry *de)
     {
     if (de.isdir)
         listdir(de.name, &callback); // recurse into subdirectories
     else
     {
         // Collect only files with mp3 and wma extensions
         auto ext = getExt(de.name);
         if (fnmatch(ext, "mp3") || fnmatch(ext, "wma"))
         files ~= de.name;
     }
     return true;    // keep going
     }
     std.file.listdir(fromdir, &callback);

     writefln(files.length, " music files");

     /* The loop will normally quit via an exception when the target device
      * is full. But if there are not enough files in the source to fill
      * up the target, the loop ensures it will still eventually quit.
      */
     while (files.length) // 0ffh: changed exit condition and loop type
     {
     auto j = std.random.rand() % files.length;
     auto fromfile = files[j];
     auto tofile = std.path.join(todir, basename(fromfile));
     writefln("%s => %s", fromfile, tofile);
     std.file.copy(fromfile, tofile);
     files[j]=files[$-1]; // 0ffh: copy last list element
     files.length=files.length-1; // 0ffh: decrease length
     }

     writefln("Done");
     return 0;
}