Bearbeiten von „Datei double finder.dart“

= Links =
* [[Projekt ddouble]]

= Zielsetzung =
Hier werden nur Besonderheiten der Datei double_finder.dart besprochen.

Viele Teile dieser Datei sind ähnlich wie [Datei search_engine.dart], z. B. das Festlegen der Optionen.

= Die Klasse SearchEngine =
Die Klasse implementiert ("realisiert") die Suche nach Duplikaten.

== Die Attribute ==
Zuerst werden die Attribute definiert:
<pre>class DoubleFinder {
  static bool storeResult = false;
  final startTime = DateTime.now();
  Map<int, List<FileInfo>> processedFiles = {};
  final int verboseLevel;
  final startLength;
  final blockSize;
  int startBlockCount = 0;
  int fullBlockCounts = 0;
  int fullBlockFiles = 0;
  int doubles = 0;
  final lines = <String>[];
  var hashBuilder = md5;
</pre>

== Der Konstruktor ==
<pre>DoubleFinder({this.verboseLevel, this.blockSize, this.startLength});
</pre>
* Keine Besonderheiten.

== Die Methode calcHash() ==
Diese Methode berechnet die Prüfsumme einer Datei.
Mit dem Parameter <code>calculateStartBlock</code> wird festgelegt, ob die Prüfsumme nur für den Dateianfang oder für die ganze Datei berechnet wird.

<pre>/// Calculates the hash value of the [file].
/// If [calculateStartBlock] is true the begin of the file is processed.
/// Otherwise the whole file content.
/// Returns an instance of [Digest] containing the hash value.
Digest calcHash(File file, {bool calculateStartBlock}) {
  Digest rc;
  try {
    final file2 = file.openSync();
    if (calculateStartBlock) {
      final buffer = file2.readSync(startLength);
      rc = hashBuilder.convert(buffer);
      startBlockCount++;
    } else {
      fullBlockFiles++;
      final output = AccumulatorSink<Digest>();
      var input = hashBuilder.startChunkedConversion(output);
      try {
        do {
          final buffer = file2.readSync(blockSize);
          if (buffer.isEmpty) {
            break;
          }
          input.add(buffer);
          fullBlockCounts++;
        } while (true);
        input.close();
        input = null;
        rc = output.events.single;
      } finally {
        if (input != null) {
          input.close();
        }
        output.close();
      }
    }
    file2.close();
  } on FileSystemException {
    rc = null;
  }
  return rc;
}
</pre>
* <code>Digest rc;</code> Diese Klasse aus dem Paket <code>crypt</code> verwaltet eine Prüfsumme.
* <code>final file2 = file.openSync();</code> Die Datei wird "geöffnet", damit wird ein Zugriff auf den Inhalt der Datei möglich.
Im Fall nur Startblock:
* <code>buffer = file2.readSync(startLength);</code> Es wird ein Block aus dem Dateiinhalt gelesen, maximal <code>startLength</code> Bytes.
* <code>rc = hashBuilder.convert(buffer);</code> Die Prüfsumme wird aus dem Dateiinhaltsblock berechnet.
Im Fall ganzer Dateiinhalt:
* <code>final output = AccumulatorSink<Digest>();</code> Ein Objekt der Klasse <code>AccumulatorSink<Digest></code> kann mit Prüfsummen umgehen.
* <code>final input = hashBuilder.startChunkedConversion(output);</code> Die Klassenvariable <code>hashBuilder</code> ist ein Objekt, das eine Prüfsumme berechnen kann, in unserem Fall MD5.
** <code>startChunkedConversion(output)</code> liefert ein Objekt, das Prüfsummen aus Einzelblöcken berechnen kann.
* <code>do {...} while(true);</code> Eine Endlosschleife, die zwischendrin mit <code>break</code> beendet wird.
* <code>final buffer = file2.readSync(blockSize);</code> Lesen eines Blockes...
* <code>if (buffer.isEmpty())</code> Konnte nichts gelesen werden, also Dateiende erreicht?
* <code>break</code> Schleife beenden.
* <code>rc = output.events.single;</code>
* <code>input.add(buffer);</code> Block für Prüfsumme verarbeiten.
* <code>finally</code> Egal ob mit oder ohne Ausnahme (Exception):
* <code>input.close(); output.close();</code> Resourcen freigeben.

== Die Methode find() ==
Diese Methode erledigt den Kern des Programms.

<pre>/// Finds the duplicates in a list of [filePatterns] respecting [fileOptions].
void find(List<String> filePatterns, FileOptions fileOptions) {
  fileOptions.yieldDirectory =
      fileOptions.yieldLinkToDirectory = fileOptions.yieldLinkToFile = false;
  fileOptions.recursive = true;
  final supplier = FileSupplier(
      fileOptions: fileOptions,
      filePatterns: filePatterns,
      verboseLevel: verboseLevel);
  final toRemove = <FileInfo>[];
  for (var filename in supplier.next()) {
    final file = supplier.currentEntity as File;
    final size = file.lengthSync();
    if (size == 0){
      continue;
    }
    var newEntry = FileInfo(filename, size);
    if (!processedFiles.containsKey(size)) {
      if (verboseLevel >= 4) {
        print('= new size $size');
      }
      processedFiles[size] = [newEntry];
      continue;
    }
    for (var processedFile in processedFiles[size]) {
      processedFile.hashStart ??= calcHash(file, calculateStartBlock: true);
      if (processedFile.hashStart == null) {
        toRemove.add(processedFile);
        continue;
      }
      newEntry.hashStart ??= calcHash(file, calculateStartBlock: true);
      if (newEntry.hashStart == null) {
        newEntry = null;
        break;
      }
      if (processedFile.hashStart == newEntry.hashStart) {
        if (verboseLevel >= 4) {
          print('= start block is the same: $filename ${processedFile.name}');
        }
        processedFile.hashFull ??=
            calcHash(File(processedFile.name), calculateStartBlock: false);
        if (processedFile.hashFull == null) {
          toRemove.add(processedFile);
          continue;
        }
        newEntry.hashFull ??= calcHash(file, calculateStartBlock: false);
        if (newEntry.hashFull == null) {
          newEntry = null;
          break;
        }
        if (processedFile.hashFull == newEntry.hashFull) {
          doubles++;
          final line = '${newEntry.name} = ${processedFile.name} size: $size';
          if (verboseLevel >= 2) {
            if (storeResult) {
              lines.add(line);
            } else {
              print(line);
            }
          }
          // we search only one duplicate.
          break;
        }
      }
    }
    for (var processedFile in toRemove) {
      processedFiles[size].remove(processedFile);
    }
    toRemove.clear();
    if (newEntry != null) {
      processedFiles[size].add(newEntry);
    }
  }
  if (verboseLevel >= 1) {
    print('= duplicates: $doubles start blocks: $startBlockCount full blocks: $fullBlockFiles files with $fullBlockCounts blocks');
    print(supplier.summary.join('\n'));
    final diff = DateTime.now().difference(startTime);
    final milliSeconds =
        (diff.inMilliseconds % 1000).toString().padLeft(3, '0');
    print(
        '= runtime: ${diff.inHours}h${diff.inMinutes % 60}m${diff.inSeconds % 60}.$milliSeconds');
  }
  if (!DoubleFinder.storeResult) {
    // Exit at once: release resources faster.
    exit(0);
  }
}
</pre>
fileOptions.yieldDirectory =
* <code>fileOptions.yieldLinkToDirectory = fileOptions.yieldLinkToFile = false;</code> Der Filenamensgenerator soll nur die Namen von reguläre Dateien liefern (keine Verzeichnisnamen, keine Links).
* <code>final toRemove = <FileInfo>[];</code> In dieser Liste merken wir uns die Einträge, die gelöscht werden müssen. Erklärung weiter unten.
* <code>for (var filename in supplier.next())</code> Die zentrale Schleife über alle Dateien der gewünschten Verzeichnisse.
* <code>final file = supplier.currentEntity as File;</code>
** Wir brauchen mehr Infos über die Datei als den Dateinamen. Diese Info ist in der Klassenvariblen <code>supplier.currentEntity</code> vorhanden.
** Diese Variable hat aber den Typ <code>FileSystemEntitity</code>, einer Oberklasse von Typ <code>File</code>. Wir haben den Generator FileSupplier() aber so konfiguriert, dass nur Dateien geliefert werden können, daher muss <code>supplier.currentEntity</code> vom Typ <code>File</code> sein.
** Daher können wir den Typ konvertieren mit <code>as Type</code>.
* <code>final size = file.lengthSync();</code> Die Variable <code>file</code> hat durch die obige Konvertierung den Typ <code>File</code> und mit <code>file.lengthSync()</code> können wir auf die Dateigröße zugreifen, was beim Typ <code>FileSystemEntitiy</code> nicht möglich ist.
* <code>var newEntry = FileInfo(filename, size);</code> Wir erstellen eine Info der Datei. Wir können nicht '''final''' verwenden, da in bestimmten Fällen <code>newEntry</code> auf <code>null</code> gesetzt wird.
* <code>if (!processedFiles.containsKey(size))</code> Die Klassenvariablen <code>processedFiles</code> ist eine <code>Map</code> mit einem Eintrag für jede schon gefundene Dateilänge. Der Wert des Schlüssel-Werte-Paares ist eine Liste der Infos über die Dateien mit dieser Länge. Wir prüfen also, ob es schon Dateien mit der Länge der aktuellen Datei gibt, genauer (wegen des <code>!</code> (not)), ob es keinen Eintrag gibt.
* <code>processedFiles[size] = [newEntry];</code> Kein Eintrag, dann erzeugen wir einen...
* <code>continue</code> ... und sind für diesen Schleifendurchgang fertig, da es nichts zu vergleichen gibt.
* Der weitere Code wird nur durchlaufen, wenn es schon Dateien mit dieser Länge gibt.
* <code>for (var processedFile in processedFiles[size])</code> Diese Schleife iteriert über alle schon gefundenen Dateien mit der Dateilänge der zu testenden Datei.
* <code>processedFile.hashStart ??= calcHash(file, calculateStartBlock: true);</code>
** Der Operator <code>??=</code> bewirkt, dass getestet wird, ob <code>processedFile</code> <code>null</code> ist. Wenn ja (und nur dann) wird der Hashwert berechnet und der Variablen zugewiesen.
* <code>if (processedFile.hashStart == null)</code> Ist der Wert trotz obiger Zeile noch <code>null</code>, ist ein Fehler in <code>calcHash()</code> aufgetreten. In diesem Fall kann also die Prüfsumme nicht berechnet werden. Da dieser Fehler bei erneutem Test (wenn noch eine Datei mit dieser Länge auftaucht) wieder auftreten könnte, entfernen wird den Eintrag aus der Liste, damit das nicht nochmal passiert:
* <code>toRemove.add(processedFile);</code> Wir dürfen nicht sofort löschen, da die Liste in einer <code>for</code>-Schleife verwendet wird, daher merken wir den Eintrag in der extra dafür vorgesehenen Liste <code>toRemove</code> ...
* <code>continue</code> ... und sind für diesen Schleifendurchlauf fertig
* <code>newEntry.hashStart ??= calcHash(file, calculateStartBlock: true);</code> Wenn <code>newEntry.hashStart</code> noch null ist, wird die Prüfsumme berechnet.
* <code>if (newEntry.hashStart == null)</code> Ist das Berechnen missglückt?
* <code>newEntry = null;</code> Fehler merken...
* <code>break;</code> ... und Schleife abbrechen
* <code>if (processedFile.hashStart == newEntry.hashStart)</code> Sind die Prüfsummen für den ersten Block gleich?
* <code>rocessedFile.hashFull ??= calcHash(File(processedFile.name), calculateStartBlock: false);</code> Wenn noch nicht berechnet, dann berechne die Prüfsumme der Gesamtdatei.
* <code>newEntry.hashFull ??= calcHash(file, calculateStartBlock: false);</code> Berechnet die Prüfsumme, wenn noch nicht erledigt.
* <code>for (var processedFile in toRemove)</code> Über alle Einträge der "zu-löschen-Liste":
* <code>processedFiles[size].remove(processedFile);</code> Eintrag löschen.
* <code>if (newEntry != null)</code> Wenn oben kein Fehler war..
* <code>processedFiles[size].add(newEntry);</code> Die Daten der aktuellen Datei für diese Dateigröße merken.