lantool

StuffItemTree.cs (7810B)

---

 using System.Collections.Generic;
 using System.IO;
 using LanTool.Classes;
 using System;
 
 namespace LanTool
 {
 	internal class StuffItemTree : StuffItem
 	{
 		#region private fields
 
 		private SortedDictionary<string, List<StuffItem>> stuffItemTreeByHash = new SortedDictionary<string, List<StuffItem>>();
 		private SortedDictionary<string, List<StuffItem>> stuffItemTreeByName = new SortedDictionary<string, List<StuffItem>>();
 		private long myDisksSpaceByClones = 0;
 		private long myDisksCountOfClones = 0;
 		private long myDisksCountOfAllowedClones = 0;
 		private long myDisksSpaceByAllowedClones = 0;
 
 		#endregion
 
 		/// <summary>
 		/// Root-Item der eigenen Platten
 		/// </summary>
 		public StuffItemTree(String path, Boolean isForeign)
 		{
 			Path = path;
 			IsOnForeignDisk = isForeign;
 			IsOnline = true;
 		}
 
 		#region public methods
 
 		public void CreateStuffItemTreeHash()
 		{
 			stuffItemTreeByHash.Clear();
 			// Rücksetzen der Werte
 			myDisksCountOfClones = 0;
 			myDisksSpaceByClones = 0;
 			myDisksCountOfAllowedClones = 0;
 			myDisksSpaceByAllowedClones = 0;
 			// Füllen eigenen Disks
 			AddStuffItemToHashes( this );
 
 			if ( !IsOnForeignDisk )
 			{
 				Program.MainWindow.Log( "Dublettensuche auf eigenen Platten..." );
 				// Ausgabe der Ergebnisse der Dublettenprüfung
 				if ( myDisksCountOfClones == 0 && myDisksCountOfAllowedClones == 0 )
 				{
 					Program.MainWindow.LogHighlight( "Keine doppelten Dateien in 'Meine Platten', gut aufgeräumt!" );
 				}
 				else
 				{
 					Program.MainWindow.LogError( "Doppelte Dateien in 'Meine Platten': " + myDisksCountOfClones.ToString() + ", das sind ca " + ( ( ( double )( myDisksSpaceByClones / 104857 ) ) / 10 ).ToString() + " MB wertvoller Plattenplatz!" );
 					Program.MainWindow.LogWarning( "Erlaubte doppelte Dateien in 'Meine Platten': " + myDisksCountOfAllowedClones.ToString() + ", das sind ca " + ( ( ( double )( myDisksSpaceByAllowedClones / 104857 ) ) / 10 ).ToString() + " MB Plattenplatz!" );
 				}
 			}
 		}
 		
 		/// <summary>
 		/// Gibt die Dublettenliste des Items zurück (ohne das Item selbst).
 		/// Eine leere Liste bedeutet also, dass das Item keine Clones hat.
 		/// </summary>
 		public List<StuffItem> GetItemClones( StuffItem item )
 		{
 			List<StuffItem> clonecopy = new List<StuffItem>();
 
 			// Alle Items mit dem gleichen Hash merken
 			List<StuffItem> clones = GetItemsRecursive( item );
 
 			// alle Items durchgehen und das Ursprungsitem wieder raussortieren
 			foreach ( StuffItem si in clones )
 			{
 				if ( si != item )
 				{
 					clonecopy.Add( si );
 				}
 			}
 			return clonecopy;
 		}
 
 		/// <summary>
 		/// Zurückgeben, wie oft ein Item (Hash-Test) im MyDisks hängt
 		/// </summary>
 		/// <param name="item"></param>
 		/// <returns></returns>
 		public int GetRecursiveItemCount( StuffItem item )
 		{
 			return GetItemsRecursive( item ).Count;
 		}
 
 		/// <summary>
 		/// Liefert alle StuffItems, die den gleichen Hash haben wie das übergebene
 		/// StuffItem
 		/// </summary>
 		/// <param name="item"></param>
 		/// <returns></returns>
 		public List<StuffItem> GetItemsRecursive( StuffItem item )
 		{
 			List<StuffItem> retList = new List<StuffItem>();
 
 			// keine Dubletten bei Dateien mit Lesefehler
 			if ( item.HasReadError )
 			{
 				return retList;
 			}
 
 			// wenn die Datei in keiner Liste enthalten ist (weder Hash noch Name), dann raus
 			if ( !stuffItemTreeByHash.ContainsKey( item.Hash ) && !stuffItemTreeByName.ContainsKey( item.Name ) )
 			{
 				return retList;
 			}
 
 			// Alle Items by Hash ermitteln
 			if (stuffItemTreeByHash.ContainsKey( item.Hash ) )
 			{
 				retList.AddRange( stuffItemTreeByHash[ item.Hash ] );
 			}
 
 			// restliche Prüfung nur, wenn die Namensprüfung angeschalten ist und die Datei auch enthalten ist
 			if ( Program.MainWindow.m_Config.IsTreatEqualNames && stuffItemTreeByName.ContainsKey( item.Name ) )
 			{
 				// wenn die Datei überhaupt vorhanden ist, dann checken ob
 				foreach ( StuffItem si in stuffItemTreeByName[ item.Name ] )
 				{
 					if ( !retList.Contains( si ) )
 					{
 						retList.Add( si );
 					}
 				}
 			}
 
 			return retList;
 		}
 
 		#endregion
 
 		#region Private methods
 
 		private void AddStuffItemToHashes( StuffItem si )
 		{
 			// nur Dateien verarbeiten
 			if ( si.IsFile )
 			{
 				// Name-Cache bearbeiten
 				if ( !stuffItemTreeByName.ContainsKey( si.Name ) )
 				{
 					stuffItemTreeByName[ si.Name ] = new List<StuffItem>();
 					stuffItemTreeByName[ si.Name ].Add( si );
 				}
 				else
 				{
 					stuffItemTreeByName[ si.Name ].Add( si );
 				}
 
 				// Hash-Cache bearbeiten
 				if ( !stuffItemTreeByHash.ContainsKey( si.Hash ) )
 				{
 					stuffItemTreeByHash[ si.Hash ] = new List<StuffItem>();
 					stuffItemTreeByHash[ si.Hash ].Add( si );
 				}
 				else
 				{
 					stuffItemTreeByHash[ si.Hash ].Add( si );
 					if ( si.IsIgnored )
 					{
 						try
 						{
 							myDisksSpaceByAllowedClones += System.Convert.ToInt64( si.Hash.Substring( 33 ), 16 );
 						}
 						catch
 						{
 						}
 						myDisksCountOfAllowedClones++;
 					}
 					else
 					{
 						try
 						{
 							myDisksSpaceByClones += System.Convert.ToInt64( si.Hash.Substring( 33 ), 16 );
 						}
 						catch
 						{
 						}
 						myDisksCountOfClones++;
 					}
 				}
 			}
 			else
 			{
 				// Verzeichnis -> alle Childs durchgehen
 				foreach ( StuffItem csi in si.ChildItems )
 				{
 					AddStuffItemToHashes( csi );
 				}
 			}
 		}
 
 		internal void RemoveStuffItemFromHashes( StuffItem si )
 		{
 			// StuffItem aus der Liste mit Hashes entfernen
 			stuffItemTreeByHash[ si.Hash ].Remove( si );
 
 			// StuffItem aus der Namensliste entfernen
 			stuffItemTreeByName[ si.Name ].Remove( si );
 		}
 
 		#endregion
 
 		#region FileSystemCache für Offline-Betrieb
 
 		private Dictionary<string, List<string>> offlineDirs = new Dictionary<string, List<string>>();
 		private Dictionary<string, List<string>> offlineFiles = new Dictionary<string, List<string>>();
 
 		public override Dictionary<string, List<string>> OfflineDirs
 		{
 			get
 			{
 				return offlineDirs;
 			}
 		}
 
 		public override Dictionary<string, List<string>> OfflineFiles
 		{
 			get
 			{
 				return offlineFiles;
 			}
 		}
 
 		/// <summary>
 		/// Offline Cache in eine Datei schreiben
 		/// </summary>
 		/// <param name="filename"></param>
 		public void SaveOfflineCacheToFile( string filename )
 		{
 			using ( StreamWriter sw = File.CreateText( filename ) )
 			{
 				foreach ( string sa in offlineDirs.Keys )
 				{
 					foreach ( string sb in offlineDirs[ sa ] )
 					{
 						sw.WriteLine( "D|" + sa + "|" + sb );
 					}
 				}
 				foreach ( string sa in offlineFiles.Keys )
 				{
 					foreach ( string sb in offlineFiles[ sa ] )
 					{
 						sw.WriteLine( "F|" + sa + "|" + sb );
 					}
 				}
 			}
 
 			Program.MainWindow.Log( "Offline-Verzeichnis wurde nach " + filename + " geschrieben" );
 		}
 
 
 		/// <summary>
 		/// Offline-Cache aus einer Datei lesen
 		/// </summary>
 		/// <param name="filename"></param>
 		public void LoadOfflineCacheFromFile( string filename )
 		{
 			using ( StreamReader sr = File.OpenText( filename ) )
 			{
 				string line;
 				while ( ( line = sr.ReadLine() ) != null )
 				{
 					string[] zeile = line.Split( '|' );
 					if ( zeile[ 0 ] == "F" )
 					{
 						if ( !OfflineFiles.ContainsKey( zeile[ 1 ] ) )
 						{
 							OfflineFiles[ zeile[ 1 ] ] = new List<string>();
 						}
 						OfflineFiles[ zeile[ 1 ] ].Add( zeile[ 2 ] );
 					}
 					else
 					{
 						if ( !offlineDirs.ContainsKey( zeile[ 1 ] ) )
 						{
 							offlineDirs[ zeile[ 1 ] ] = new List<string>();
 						}
 						offlineDirs[ zeile[ 1 ] ].Add( zeile[ 2 ] );
 					}
 				}
 			}
 			IsOnline = false;
 		}
 
 		/// <summary>
 		/// Simulation des Filesystems abschalten und zurücksetzen
 		/// </summary>
 		public void ResetOfflineCaches()
 		{
 			offlineDirs.Clear();
 			offlineFiles.Clear();
 		}
 
 		#endregion
 	}
 }