[SabreTools.Helper] Move some things around

SabreTools.Helper/Objects/Dat/Archive.cs

@@ -0,0 +1,91 @@
+namespace SabreTools.Helper
+{
+	public class Archive : DatItem
+	{
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Archive object
+		/// </summary>
+		public Archive()
+		{
+			_name = "";
+			_itemType = ItemType.Archive;
+		}
+
+		/// <summary>
+		/// Create a new Archive object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		public Archive(string name)
+		{
+			_name = name;
+			_itemType = ItemType.Archive;
+		}
+
+		/// <summary>
+		/// Create a new Archive object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public Archive(string name, string machineName, string comment, string machineDescription, string year,
+			string manufacturer, string romOf, string cloneOf, string sampleOf, string sourceFile, bool isBios, string board, string rebuildTo,
+			int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.Archive;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			// If we don't have an archive, return false
+			if (_itemType != other.Type)
+			{
+				return false;
+			}
+
+			// Otherwise, treat it as an archive
+			Archive newOther = (Archive)other;
+
+			// If the archive information matches
+			return (_name == newOther.Name);
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/BiosSet.cs

@@ -0,0 +1,121 @@
+namespace SabreTools.Helper
+{
+	public class BiosSet : DatItem
+	{
+		#region Private instance variables
+
+		private string _description;
+		private bool? _default;
+
+		#endregion
+
+		#region Publicly facing variables
+
+		public string Description
+		{
+			get { return _description; }
+			set { _description = value; }
+		}
+		public bool? Default
+		{
+			get { return _default; }
+			set { _default = value; }
+		}
+
+		#endregion
+
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Sample object
+		/// </summary>
+		public BiosSet()
+		{
+			_name = "";
+			_itemType = ItemType.BiosSet;
+		}
+
+		/// <summary>
+		/// Create a new Sample object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="description">Description of the Bios set item</param>
+		/// <param name="default">True if this is the default BIOS, false if it is not, null for undefined</param>
+		public BiosSet(string name, string description, bool? @default)
+		{
+			_name = name;
+			_itemType = ItemType.BiosSet;
+			_description = description;
+			_default = @default;
+		}
+
+		/// <summary>
+		/// Create a new Sample object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="description">Description of the Bios set item</param>
+		/// <param name="default">True if this is the default BIOS, false if it is not, null for undefined</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public BiosSet(string name, string description, bool? @default, string machineName, string comment, string machineDescription, string year,
+			string manufacturer, string romOf, string cloneOf, string sampleOf, string sourceFile, bool isBios, string board, string rebuildTo,
+			int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.BiosSet;
+			_description = description;
+			_default = @default;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			// If we don't have a biosset, return false
+			if (_itemType != other.Type)
+			{
+				return false;
+			}
+
+			// Otherwise, treat it as a biosset
+			BiosSet newOther = (BiosSet)other;
+
+			// If the archive information matches
+			return (_name == newOther.Name && _description == newOther.Description && _default == newOther.Default);
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/DatItem.cs

@@ -0,0 +1,784 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace SabreTools.Helper
+{
+	public abstract class DatItem : IEquatable<DatItem>, IComparable<DatItem>
+	{
+		#region Protected instance variables
+
+		// Standard item information
+		protected string _name;
+		protected ItemType _itemType;
+		protected DupeType _dupeType;
+
+		// Machine information
+		protected string _machineName;
+		protected string _comment;
+		protected string _machineDescription;
+		protected string _year;
+		protected string _manufacturer;
+		protected string _romOf;
+		protected string _cloneOf;
+		protected string _sampleOf;
+		protected string _sourceFile;
+		protected bool _isBios;
+		protected string _board;
+		protected string _rebuildTo;
+
+		// Source metadata information
+		protected int _systemId;
+		protected string _systemName;
+		protected int _sourceId;
+		protected string _sourceName;
+
+		#endregion
+
+		#region Publicly facing variables
+
+		// Standard item information
+		public string Name
+		{
+			get { return _name; }
+			set { _name = value; }
+		}
+		public ItemType Type
+		{
+			get { return _itemType; }
+			set { _itemType = value; }
+		}
+		public DupeType Dupe
+		{
+			get { return _dupeType; }
+			set { _dupeType = value; }
+		}
+
+		// Machine information
+		public string MachineName
+		{
+			get { return _machineName; }
+			set { _machineName = value; }
+		}
+		public string Comment
+		{
+			get { return _comment; }
+			set { _comment = value; }
+		}
+		public string MachineDescription
+		{
+			get { return _machineDescription; }
+			set { _machineDescription = value; }
+		}
+		public string Year
+		{
+			get { return _year; }
+			set { _year = value; }
+		}
+		public string Manufacturer
+		{
+			get { return _manufacturer; }
+			set { _manufacturer = value; }
+		}
+		public string RomOf
+		{
+			get { return _romOf; }
+			set { _romOf = value; }
+		}
+		public string CloneOf
+		{
+			get { return _cloneOf; }
+			set { _cloneOf = value; }
+		}
+		public string SampleOf
+		{
+			get { return _sampleOf; }
+			set { _sampleOf = value; }
+		}
+		public string SourceFile
+		{
+			get { return _sourceFile; }
+			set { _sourceFile = value; }
+		}
+		public bool IsBios
+		{
+			get { return _isBios; }
+			set { _isBios = value; }
+		}
+		public string Board
+		{
+			get { return _board; }
+			set { _board = value; }
+		}
+		public string RebuildTo
+		{
+			get { return _rebuildTo; }
+			set { _rebuildTo = value; }
+		}
+
+		// Source metadata information
+		public int SystemID
+		{
+			get { return _systemId; }
+			set { _systemId = value; }
+		}
+		public string System
+		{
+			get { return _systemName; }
+			set { _systemName = value; }
+		}
+		public int SourceID
+		{
+			get { return _sourceId; }
+			set { _sourceId = value; }
+		}
+		public string Source
+		{
+			get { return _sourceName; }
+			set { _sourceName = value; }
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public int CompareTo(DatItem other)
+		{
+			int ret = 0;
+
+			try
+			{
+				if (_name == other.Name)
+				{
+					ret = (this.Equals(other) ? 0 : 1);
+				}
+				ret = String.Compare(_name, other.Name);
+			}
+			catch
+			{
+				ret = 1;
+			}
+
+			return ret;
+		}
+
+		public abstract bool Equals(DatItem other);
+
+		/// <summary>
+		/// Determine if an item is a duplicate using partial matching logic
+		/// </summary>
+		/// <param name="lastItem">DatItem to use as a baseline</param>
+		/// <param name="logger">Logger object for console and/or file output</param>
+		/// <returns>True if the roms are duplicates, false otherwise</returns>
+		public bool IsDuplicate(DatItem lastItem, Logger logger)
+		{
+			bool dupefound = this.Equals(lastItem);
+
+			// More wonderful SHA-1 logging that has to be done
+			if (_itemType == ItemType.Rom)
+			{
+				if (((Rom)this).SHA1 == ((Rom)lastItem).SHA1 && ((Rom)this).Size != ((Rom)lastItem).Size)
+				{
+					logger.User("SHA-1 mismatch - Hash: " + ((Rom)this).SHA1);
+				}
+			}
+
+			return dupefound;
+		}
+
+		/// <summary>
+		/// Return the duplicate status of two items
+		/// </summary>
+		/// <param name="lastItem">DatItem to check against</param>
+		/// <param name="logger">Logger object for console and/or file output</param>
+		/// <returns>The DupeType corresponding to the relationship between the two</returns>
+		public DupeType GetDuplicateStatus(DatItem lastItem, Logger logger)
+		{
+			DupeType output = DupeType.None;
+
+			// If we don't have a duplicate at all, return none
+			if (!this.IsDuplicate(lastItem, logger))
+			{
+				return output;
+			}
+
+			// If the duplicate is external already or should be, set it
+			if (lastItem.Dupe >= DupeType.ExternalHash || lastItem.SystemID != this.SystemID || lastItem.SourceID != this.SourceID)
+			{
+				if (lastItem.MachineName == this.MachineName && lastItem.Name == this.Name)
+				{
+					output = DupeType.ExternalAll;
+				}
+				else
+				{
+					output = DupeType.ExternalHash;
+				}
+			}
+
+			// Otherwise, it's considered an internal dupe
+			else
+			{
+				if (lastItem.MachineName == this.MachineName && lastItem.Name == this.Name)
+				{
+					output = DupeType.InternalAll;
+				}
+				else
+				{
+					output = DupeType.InternalHash;
+				}
+			}
+
+			return output;
+		}
+
+		#endregion
+
+		#region Sorting and merging
+
+		/// <summary>
+		/// Determine if a rom should be included based on filters
+		/// </summary>
+		/// <param name="itemdata">User supplied item to check</param>
+		/// <param name="gamename">Name of the game to match (can use asterisk-partials)</param>
+		/// <param name="romname">Name of the rom to match (can use asterisk-partials)</param>
+		/// <param name="romtype">Type of the rom to match</param>
+		/// <param name="sgt">Find roms greater than or equal to this size</param>
+		/// <param name="slt">Find roms less than or equal to this size</param>
+		/// <param name="seq">Find roms equal to this size</param>
+		/// <param name="crc">CRC of the rom to match (can use asterisk-partials)</param>
+		/// <param name="md5">MD5 of the rom to match (can use asterisk-partials)</param>
+		/// <param name="sha1">SHA-1 of the rom to match (can use asterisk-partials)</param>
+		/// <param name="nodump">Select roms with nodump status as follows: null (match all), true (match Nodump only), false (exclude Nodump)</param>
+		/// <param name="logger">Logging object for console and file output</param>
+		/// <returns>Returns true if it should be included, false otherwise</returns>
+		public static bool Filter(DatItem itemdata, string gamename, string romname, string romtype, long sgt,
+			long slt, long seq, string crc, string md5, string sha1, bool? nodump, Logger logger)
+		{
+			// Take care of Rom and Disk specific differences
+			if (itemdata.Type == ItemType.Rom)
+			{
+				Rom rom = (Rom)itemdata;
+
+				// Filter on nodump status
+				if (nodump == true && !rom.Nodump)
+				{
+					return false;
+				}
+				if (nodump == false && rom.Nodump)
+				{
+					return false;
+				}
+
+				// Filter on rom size
+				if (seq != -1 && rom.Size != seq)
+				{
+					return false;
+				}
+				else
+				{
+					if (sgt != -1 && rom.Size < sgt)
+					{
+						return false;
+					}
+					if (slt != -1 && rom.Size > slt)
+					{
+						return false;
+					}
+				}
+
+				// Filter on crc
+				if (!String.IsNullOrEmpty(crc))
+				{
+					if (crc.StartsWith("*") && crc.EndsWith("*"))
+					{
+						if (!rom.CRC.ToLowerInvariant().Contains(crc.ToLowerInvariant().Replace("*", "")))
+						{
+							return false;
+						}
+					}
+					else if (crc.StartsWith("*"))
+					{
+						if (!rom.CRC.EndsWith(crc.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else if (crc.EndsWith("*"))
+					{
+						if (!rom.CRC.StartsWith(crc.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else
+					{
+						if (!String.Equals(rom.CRC, crc, StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+				}
+
+				// Filter on md5
+				if (!String.IsNullOrEmpty(md5))
+				{
+					if (md5.StartsWith("*") && md5.EndsWith("*"))
+					{
+						if (!rom.MD5.ToLowerInvariant().Contains(md5.ToLowerInvariant().Replace("*", "")))
+						{
+							return false;
+						}
+					}
+					else if (md5.StartsWith("*"))
+					{
+						if (!rom.MD5.EndsWith(md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else if (md5.EndsWith("*"))
+					{
+						if (!rom.MD5.StartsWith(md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else
+					{
+						if (!String.Equals(rom.MD5, md5, StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+				}
+
+				// Filter on sha1
+				if (!String.IsNullOrEmpty(sha1))
+				{
+					if (sha1.StartsWith("*") && sha1.EndsWith("*"))
+					{
+						if (!rom.SHA1.ToLowerInvariant().Contains(sha1.ToLowerInvariant().Replace("*", "")))
+						{
+							return false;
+						}
+					}
+					else if (sha1.StartsWith("*"))
+					{
+						if (!rom.SHA1.EndsWith(sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else if (sha1.EndsWith("*"))
+					{
+						if (!rom.SHA1.StartsWith(sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else
+					{
+						if (!String.Equals(rom.SHA1, sha1, StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+				}
+			}
+			else if (itemdata.Type == ItemType.Disk)
+			{
+				Disk rom = (Disk)itemdata;
+
+				// Filter on nodump status
+				if (nodump == true && !rom.Nodump)
+				{
+					return false;
+				}
+				if (nodump == false && rom.Nodump)
+				{
+					return false;
+				}
+
+				// Filter on md5
+				if (!String.IsNullOrEmpty(md5))
+				{
+					if (md5.StartsWith("*") && md5.EndsWith("*"))
+					{
+						if (!rom.MD5.ToLowerInvariant().Contains(md5.ToLowerInvariant().Replace("*", "")))
+						{
+							return false;
+						}
+					}
+					else if (md5.StartsWith("*"))
+					{
+						if (!rom.MD5.EndsWith(md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else if (md5.EndsWith("*"))
+					{
+						if (!rom.MD5.StartsWith(md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else
+					{
+						if (!String.Equals(rom.MD5, md5, StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+				}
+
+				// Filter on sha1
+				if (!String.IsNullOrEmpty(sha1))
+				{
+					if (sha1.StartsWith("*") && sha1.EndsWith("*"))
+					{
+						if (!rom.SHA1.ToLowerInvariant().Contains(sha1.ToLowerInvariant().Replace("*", "")))
+						{
+							return false;
+						}
+					}
+					else if (sha1.StartsWith("*"))
+					{
+						if (!rom.SHA1.EndsWith(sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else if (sha1.EndsWith("*"))
+					{
+						if (!rom.SHA1.StartsWith(sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+					else
+					{
+						if (!String.Equals(rom.SHA1, sha1, StringComparison.InvariantCultureIgnoreCase))
+						{
+							return false;
+						}
+					}
+				}
+			}
+
+			// Filter on game name
+			if (!String.IsNullOrEmpty(gamename))
+			{
+				if (gamename.StartsWith("*") && gamename.EndsWith("*"))
+				{
+					if (!itemdata.MachineName.ToLowerInvariant().Contains(gamename.ToLowerInvariant().Replace("*", "")))
+					{
+						return false;
+					}
+				}
+				else if (gamename.StartsWith("*"))
+				{
+					if (!itemdata.MachineName.EndsWith(gamename.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+				else if (gamename.EndsWith("*"))
+				{
+					if (!itemdata.MachineName.StartsWith(gamename.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+				else
+				{
+					if (!String.Equals(itemdata.MachineName, gamename, StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+			}
+
+			// Filter on rom name
+			if (!String.IsNullOrEmpty(romname))
+			{
+				if (romname.StartsWith("*") && romname.EndsWith("*"))
+				{
+					if (!itemdata.Name.ToLowerInvariant().Contains(romname.ToLowerInvariant().Replace("*", "")))
+					{
+						return false;
+					}
+				}
+				else if (romname.StartsWith("*"))
+				{
+					if (!itemdata.Name.EndsWith(romname.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+				else if (romname.EndsWith("*"))
+				{
+					if (!itemdata.Name.StartsWith(romname.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+				else
+				{
+					if (!String.Equals(itemdata.Name, romname, StringComparison.InvariantCultureIgnoreCase))
+					{
+						return false;
+					}
+				}
+			}
+
+			// Filter on rom type
+			if (String.IsNullOrEmpty(romtype) && itemdata.Type != ItemType.Rom && itemdata.Type != ItemType.Disk)
+			{
+				return false;
+			}
+			if (!String.IsNullOrEmpty(romtype) && !String.Equals(itemdata.Type.ToString(), romtype, StringComparison.InvariantCultureIgnoreCase))
+			{
+				return false;
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		/// Merge an arbitrary set of ROMs based on the supplied information
+		/// </summary>
+		/// <param name="infiles">List of File objects representing the roms to be merged</param>
+		/// <param name="logger">Logger object for console and/or file output</param>
+		/// <returns>A List of RomData objects representing the merged roms</returns>
+		public static List<DatItem> Merge(List<DatItem> infiles, Logger logger)
+		{
+			// Check for null or blank roms first
+			if (infiles == null || infiles.Count == 0)
+			{
+				return new List<DatItem>();
+			}
+
+			// Create output list
+			List<DatItem> outfiles = new List<DatItem>();
+
+			// Then deduplicate them by checking to see if data matches previous saved roms
+			foreach (DatItem file in infiles)
+			{
+				// If it's a nodump, add and skip
+				if (file.Type == ItemType.Rom && ((Rom)file).Nodump)
+				{
+					outfiles.Add(file);
+					continue;
+				}
+				else if (file.Type == ItemType.Disk && ((Disk)file).Nodump)
+				{
+					outfiles.Add(file);
+					continue;
+				}
+
+				// If it's the first rom in the list, don't touch it
+				if (outfiles.Count != 0)
+				{
+					// Check if the rom is a duplicate
+					DupeType dupetype = DupeType.None;
+					DatItem saveditem = new Rom();
+					int pos = -1;
+					for (int i = 0; i < outfiles.Count; i++)
+					{
+						DatItem lastrom = outfiles[i];
+
+						// Get the duplicate status
+						dupetype = file.GetDuplicateStatus(lastrom, logger);
+
+						// If it's a duplicate, skip adding it to the output but add any missing information
+						if (dupetype != DupeType.None)
+						{
+							// If we don't have a rom or disk, then just skip adding
+							if (file.Type != ItemType.Rom && file.Type != ItemType.Disk)
+							{
+								continue;
+							}
+
+							saveditem = lastrom;
+							pos = i;
+
+							// Roms have more infomration to save
+							if (file.Type == ItemType.Rom)
+							{
+								((Rom)saveditem).Size = ((Rom)saveditem).Size;
+								((Rom)saveditem).CRC = (String.IsNullOrEmpty(((Rom)saveditem).CRC) && !String.IsNullOrEmpty(((Rom)file).CRC)
+									? ((Rom)file).CRC
+									: ((Rom)saveditem).CRC);
+								((Rom)saveditem).MD5 = (String.IsNullOrEmpty(((Rom)saveditem).MD5) && !String.IsNullOrEmpty(((Rom)file).MD5)
+									? ((Rom)file).MD5
+									: ((Rom)saveditem).MD5);
+								((Rom)saveditem).SHA1 = (String.IsNullOrEmpty(((Rom)saveditem).SHA1) && !String.IsNullOrEmpty(((Rom)file).SHA1)
+									? ((Rom)file).SHA1
+									: ((Rom)saveditem).SHA1);
+							}
+							else
+							{
+								((Disk)saveditem).MD5 = (String.IsNullOrEmpty(((Disk)saveditem).MD5) && !String.IsNullOrEmpty(((Disk)file).MD5)
+									? ((Disk)file).MD5
+									: ((Disk)saveditem).MD5);
+								((Disk)saveditem).SHA1 = (String.IsNullOrEmpty(((Disk)saveditem).SHA1) && !String.IsNullOrEmpty(((Disk)file).SHA1)
+									? ((Disk)file).SHA1
+									: ((Disk)saveditem).SHA1);
+							}
+
+							saveditem.Dupe = dupetype;
+
+							// If the current system has a lower ID than the previous, set the system accordingly
+							if (file.SystemID < saveditem.SystemID)
+							{
+								saveditem.SystemID = file.SystemID;
+								saveditem.System = file.System;
+								saveditem.MachineName = file.MachineName;
+								saveditem.Name = file.Name;
+							}
+
+							// If the current source has a lower ID than the previous, set the source accordingly
+							if (file.SourceID < saveditem.SourceID)
+							{
+								saveditem.SourceID = file.SourceID;
+								saveditem.Source = file.Source;
+								saveditem.MachineName = file.MachineName;
+								saveditem.Name = file.Name;
+							}
+
+							break;
+						}
+					}
+
+					// If no duplicate is found, add it to the list
+					if (dupetype == DupeType.None)
+					{
+						outfiles.Add(file);
+					}
+					// Otherwise, if a new rom information is found, add that
+					else
+					{
+						outfiles.RemoveAt(pos);
+						outfiles.Insert(pos, saveditem);
+					}
+				}
+				else
+				{
+					outfiles.Add(file);
+				}
+			}
+
+			// Then return the result
+			return outfiles;
+		}
+
+		/// <summary>
+		/// List all duplicates found in a DAT based on a rom
+		/// </summary>
+		/// <param name="lastitem">Item to use as a base</param>
+		/// <param name="datdata">Dat to match against</param>
+		/// <param name="logger">Logger object for console and/or file output</param>
+		/// <param name="remove">True to remove matched roms from the input, false otherwise (default)</param>
+		/// <returns>List of matched DatItem objects</returns>
+		public static List<DatItem> GetDuplicates(DatItem lastitem, DatFile datdata, Logger logger, bool remove = false)
+		{
+			List<DatItem> output = new List<DatItem>();
+
+			// Check for an empty rom list first
+			if (datdata.Files == null || datdata.Files.Count == 0)
+			{
+				return output;
+			}
+
+			// Try to find duplicates
+			List<string> keys = datdata.Files.Keys.ToList();
+			foreach (string key in keys)
+			{
+				List<DatItem> roms = datdata.Files[key];
+				List<DatItem> left = new List<DatItem>();
+
+				foreach (DatItem rom in roms)
+				{
+					if (rom.IsDuplicate(lastitem, logger))
+					{
+						output.Add(rom);
+					}
+					else
+					{
+						left.Add(rom);
+					}
+				}
+
+				// If we're in removal mode, replace the list with the new one
+				if (remove)
+				{
+					datdata.Files[key] = left;
+				}
+			}
+
+			return output;
+		}
+
+		/// <summary>
+		/// Sort a list of File objects by SystemID, SourceID, Game, and Name (in order)
+		/// </summary>
+		/// <param name="roms">List of File objects representing the roms to be sorted</param>
+		/// <param name="norename">True if files are not renamed, false otherwise</param>
+		/// <returns>True if it sorted correctly, false otherwise</returns>
+		public static bool Sort(ref List<DatItem> roms, bool norename)
+		{
+			try
+			{
+				roms.Sort(delegate (DatItem x, DatItem y)
+				{
+					if (x.SystemID == y.SystemID)
+					{
+						if (x.SourceID == y.SourceID)
+						{
+							if (x.MachineName == y.MachineName)
+							{
+								if ((x.Type == ItemType.Rom || x.Type == ItemType.Disk) && (y.Type == ItemType.Rom || y.Type == ItemType.Disk))
+								{
+									if (Path.GetDirectoryName(x.Name) == Path.GetDirectoryName(y.Name))
+									{
+										return Style.CompareNumeric(Path.GetFileName(x.Name), Path.GetFileName(y.Name));
+									}
+									return Style.CompareNumeric(Path.GetDirectoryName(x.Name), Path.GetDirectoryName(y.Name));
+								}
+								else if ((x.Type == ItemType.Rom || x.Type == ItemType.Disk) && (y.Type != ItemType.Rom && y.Type != ItemType.Disk))
+								{
+									return -1;
+								}
+								else if ((x.Type != ItemType.Rom && x.Type != ItemType.Disk) && (y.Type == ItemType.Rom || y.Type == ItemType.Disk))
+								{
+									return 1;
+								}
+								else
+								{
+									if (Path.GetDirectoryName(x.Name) == Path.GetDirectoryName(y.Name))
+									{
+										return Style.CompareNumeric(Path.GetFileName(x.Name), Path.GetFileName(y.Name));
+									}
+									return Style.CompareNumeric(Path.GetDirectoryName(x.Name), Path.GetDirectoryName(y.Name));
+								}
+							}
+							return Style.CompareNumeric(x.MachineName, y.MachineName);
+						}
+						return (norename ? Style.CompareNumeric(x.MachineName, y.MachineName) : x.SourceID - y.SourceID);
+					}
+					return (norename ? Style.CompareNumeric(x.MachineName, y.MachineName) : x.SystemID - y.SystemID);
+				});
+				return true;
+			}
+			catch (Exception)
+			{
+				// Absorb the error
+				return false;
+			}
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/Disk.cs

@@ -0,0 +1,152 @@
+using System;
+
+namespace SabreTools.Helper
+{
+	public class Disk : DatItem
+	{
+		#region Private instance variables
+
+		// Disk information
+		protected string _md5;
+		protected string _sha1;
+		// private string _merge;
+		// private DiskStatus _romStatus;
+		protected bool _nodump;
+
+		#endregion
+
+		#region Publicly facing variables
+
+		// Disk information
+		public string MD5
+		{
+			get { return _md5; }
+			set { _md5 = value; }
+		}
+		public string SHA1
+		{
+			get { return _sha1; }
+			set { _sha1 = value; }
+		}
+		public bool Nodump
+		{
+			get { return _nodump; }
+			set { _nodump = value; }
+		}
+
+		#endregion
+
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Disk object
+		/// </summary>
+		public Disk()
+		{
+			_name = "";
+			_itemType = ItemType.Disk;
+			_dupeType = DupeType.None;
+			_nodump = false;
+		}
+
+		/// <summary>
+		/// Create a new Disk object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="md5">String representation of the MD5</param>
+		/// <param name="sha1">String representation of the SHA-1</param>
+		/// <param name="nodump">True if the file is a nodump, false otherwise</param>
+		public Disk(string name, string md5, string sha1, bool nodump)
+		{
+			_name = name;
+			_itemType = ItemType.Disk;
+			_md5 = md5?.ToLowerInvariant();
+			_sha1 = sha1?.ToLowerInvariant();
+			_nodump = nodump;
+		}
+
+		/// <summary>
+		/// Create a new Disk object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="md5">String representation of the MD5</param>
+		/// <param name="sha1">String representation of the SHA-1</param>
+		/// <param name="nodump">True if the file is a nodump, false otherwise</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public Disk(string name, string md5, string sha1, bool nodump, string machineName, string comment,
+			string machineDescription, string year, string manufacturer, string romOf, string cloneOf, string sampleOf, string sourceFile,
+			bool isBios, string board, string rebuildTo, int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.Disk;
+			_md5 = md5?.ToLowerInvariant();
+			_sha1 = sha1?.ToLowerInvariant();
+			_nodump = nodump;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			bool dupefound = false;
+
+			// If we don't have a rom, return false
+			if (_itemType != other.Type)
+			{
+				return dupefound;
+			}
+
+			// Otherwise, treat it as a rom
+			Disk newOther = (Disk)other;
+
+			// If either is a nodump, it's never a match
+			if (_nodump || newOther.Nodump)
+			{
+				return dupefound;
+			}
+
+			if (((String.IsNullOrEmpty(_md5) || String.IsNullOrEmpty(newOther.MD5)) || this.MD5 == newOther.MD5) &&
+					((String.IsNullOrEmpty(this.SHA1) || String.IsNullOrEmpty(newOther.SHA1)) || this.SHA1 == newOther.SHA1))
+			{
+				dupefound = true;
+			}
+
+			return dupefound;
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/Release.cs

@@ -0,0 +1,149 @@
+namespace SabreTools.Helper
+{
+	public class Release : DatItem
+	{
+		#region Private instance variables
+
+		private string _region;
+		private string _language;
+		private string _date;
+		private bool? _default;
+
+		#endregion
+
+		#region Publicly facing variables
+
+		public string Region
+		{
+			get { return _region; }
+			set { _region = value; }
+		}
+		public string Language
+		{
+			get { return _language; }
+			set { _language = value; }
+		}
+		public string Date
+		{
+			get { return _date; }
+			set { _date = value; }
+		}
+		public bool? Default
+		{
+			get { return _default; }
+			set { _default = value; }
+		}
+
+		#endregion
+
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Release object
+		/// </summary>
+		public Release()
+		{
+			_name = "";
+			_itemType = ItemType.Release;
+			_region = "";
+			_language = "";
+			_date = "";
+			_default = null;
+		}
+
+		/// <summary>
+		/// Create a new Release object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="region">Region of the item</param>
+		/// <param name="language">Language of the item</param>
+		/// <param name="date">String representation of the Date</param>
+		/// <param name="default">True if this is the default BIOS, false if it is not, null for undefined</param>
+		public Release(string name, string region, string language, string date, bool? @default)
+		{
+			_name = name;
+			_itemType = ItemType.Release;
+			_region = region;
+			_language = language;
+			_date = date;
+			_default = @default;
+		}
+
+		/// <summary>
+		/// Create a new Release object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="region">Region of the item</param>
+		/// <param name="language">Language of the item</param>
+		/// <param name="date">String representation of the Date</param>
+		/// <param name="default">True if this is the default BIOS, false if it is not, null for undefined</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public Release(string name, string region, string language, string date, bool? @default, string machineName, string comment,
+			string machineDescription, string year, string manufacturer, string romOf, string cloneOf, string sampleOf, string sourceFile,
+			bool isBios, string board, string rebuildTo, int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.Release;
+			_region = region;
+			_language = language;
+			_date = date;
+			_default = @default;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			// If we don't have a release return false
+			if (_itemType != other.Type)
+			{
+				return false;
+			}
+
+			// Otherwise, treat it as a reease
+			Release newOther = (Release)other;
+
+			// If the archive information matches
+			return (_name == newOther.Name
+				&& _region == newOther.Region
+				&& _language == newOther.Language
+				&& _date == newOther.Date
+				&& _default == newOther.Default);
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/Rom.cs

@@ -0,0 +1,175 @@
+using System;
+
+namespace SabreTools.Helper
+{
+	public class Rom : Disk
+	{
+		#region Private instance variables
+
+		// Rom information
+		protected long _size;
+		protected string _crc;
+		private string _date;
+
+		#endregion
+
+		#region Publicly facing variables
+
+		// Rom information
+		public long Size
+		{
+			get { return _size; }
+			set { _size = value; }
+		}
+		public string CRC
+		{
+			get { return _crc; }
+			set { _crc = value; }
+		}
+		public string Date
+		{
+			get { return _date; }
+			set { _date = value; }
+		}
+
+		#endregion
+
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Rom object
+		/// </summary>
+		public Rom()
+		{
+			_name = "";
+			_itemType = ItemType.Rom;
+			_dupeType = DupeType.None;
+			_nodump = false;
+			_date = "";
+		}
+
+		/// <summary>
+		/// Create a "blank" Rom object
+		/// </summary>
+		/// <param name="name"></param>
+		/// <param name="machineName"></param>
+		public Rom(string name, string machineName) :
+			this(name, -1, "null", "null", "null", false, null, machineName, null, machineName, null, null, null, null, null, null, false, null, null, -1, null, -1, null)
+		{
+		}
+
+		/// <summary>
+		/// Create a new Rom object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="size">Long size of the item</param>
+		/// <param name="crc">String representation of the CRC</param>
+		/// <param name="md5">String representation of the MD5</param>
+		/// <param name="sha1">String representation of the SHA-1</param>
+		/// <param name="nodump">True if the file is a nodump, false otherwise</param>
+		/// <param name="date">String representation of the Date</param>
+		public Rom(string name, long size, string crc, string md5, string sha1, bool nodump, string date)
+		{
+			_name = name;
+			_itemType = ItemType.Rom;
+			_size = size;
+			_crc = crc?.ToLowerInvariant();
+			_md5 = md5?.ToLowerInvariant();
+			_sha1 = sha1?.ToLowerInvariant();
+			_nodump = nodump;
+			_date = date;
+		}
+
+		/// <summary>
+		/// Create a new Rom object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="size">Long size of the item</param>
+		/// <param name="crc">String representation of the CRC</param>
+		/// <param name="md5">String representation of the MD5</param>
+		/// <param name="sha1">String representation of the SHA-1</param>
+		/// <param name="nodump">True if the file is a nodump, false otherwise</param>
+		/// <param name="date">String representation of the Date</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public Rom(string name, long size, string crc, string md5, string sha1, bool nodump, string date, string machineName,
+			string comment, string machineDescription, string year, string manufacturer, string romOf, string cloneOf, string sampleOf,
+			string sourceFile, bool isBios, string board, string rebuildTo, int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.Rom;
+			_size = size;
+			_crc = crc?.ToLowerInvariant();
+			_md5 = md5?.ToLowerInvariant();
+			_sha1 = sha1?.ToLowerInvariant();
+			_nodump = nodump;
+			_date = date;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			bool dupefound = false;
+
+			// If we don't have a rom, return false
+			if (_itemType != other.Type)
+			{
+				return dupefound;
+			}
+
+			// Otherwise, treat it as a rom
+			Rom newOther = (Rom)other;
+
+			// If either is a nodump, it's never a match
+			if (_nodump || newOther.Nodump)
+			{
+				return dupefound;
+			}
+
+			if ((this.Size == newOther.Size) &&
+				((String.IsNullOrEmpty(this.CRC) || String.IsNullOrEmpty(newOther.CRC)) || this.CRC == newOther.CRC) &&
+				((String.IsNullOrEmpty(this.MD5) || String.IsNullOrEmpty(newOther.MD5)) || this.MD5 == newOther.MD5) &&
+				((String.IsNullOrEmpty(this.SHA1) || String.IsNullOrEmpty(newOther.SHA1)) || this.SHA1 == newOther.SHA1))
+			{
+				dupefound = true;
+			}
+
+			return dupefound;
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Dat/Sample.cs

@@ -0,0 +1,91 @@
+namespace SabreTools.Helper
+{
+	public class Sample : DatItem
+	{
+		#region Constructors
+
+		/// <summary>
+		/// Create a default, empty Sample object
+		/// </summary>
+		public Sample()
+		{
+			_name = "";
+			_itemType = ItemType.Sample;
+		}
+
+		/// <summary>
+		/// Create a new Sample object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		public Sample(string name)
+		{
+			_name = name;
+			_itemType = ItemType.Sample;
+		}
+
+		/// <summary>
+		/// Create a new Sample object with the included information
+		/// </summary>
+		/// <param name="name">Name of the item, including extension</param>
+		/// <param name="machineName">Name for the machine/game</param>
+		/// <param name="comment">Comment for the machine/game</param>
+		/// <param name="machineDescription">Description for the machine/game</param>
+		/// <param name="year">Year for the machine/game</param>
+		/// <param name="manufacturer">Manufacturer name for the machine/game</param>
+		/// <param name="romOf">Set that this machine/game is a rom of</param>
+		/// <param name="cloneOf">Set that this machine/game is a clone of</param>
+		/// <param name="sampleOf">Set that this machine/game is a sample of</param>
+		/// <param name="sourceFile">Source file for the machine/game</param>
+		/// <param name="isBios">True if this game is a BIOS, false otherwise</param>
+		/// <param name="board">Name of the board for this machine/game</param>
+		/// <param name="rebuildTo">Name of the game to rebuild to</param>
+		/// <param name="systemId">System ID to be associated with</param>
+		/// <param name="systemName">System Name to be associated with</param>
+		/// <param name="sourceId">Source ID to be associated with</param>
+		/// <param name="sourceName">Source Name to be associated with</param>
+		public Sample(string name, string machineName, string comment, string machineDescription, string year,
+			string manufacturer, string romOf, string cloneOf, string sampleOf, string sourceFile, bool isBios, string board, string rebuildTo,
+			int systemId, string systemName, int sourceId, string sourceName)
+		{
+			_name = name;
+			_itemType = ItemType.Sample;
+			_machineName = machineName;
+			_comment = comment;
+			_machineDescription = machineDescription;
+			_year = year;
+			_manufacturer = manufacturer;
+			_romOf = romOf;
+			_cloneOf = cloneOf;
+			_sampleOf = sampleOf;
+			_sourceFile = sourceFile;
+			_isBios = isBios;
+			_board = board;
+			_rebuildTo = rebuildTo;
+			_systemId = systemId;
+			_systemName = systemName;
+			_sourceId = sourceId;
+			_sourceName = sourceName;
+		}
+
+		#endregion
+
+		#region Comparision Methods
+
+		public override bool Equals(DatItem other)
+		{
+			// If we don't have a sample, return false
+			if (_itemType != other.Type)
+			{
+				return false;
+			}
+
+			// Otherwise, treat it as a sample
+			Sample newOther = (Sample)other;
+
+			// If the archive information matches
+			return (_name == newOther.Name);
+		}
+
+		#endregion
+	}
+}