claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove Field usage

Browse Source
This commit is contained in:
Matt Nadareski
2020-12-14 15:43:01 -08:00
parent 52d1673cb8
commit 8870e9b287
13 changed files with 81 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
SabreTools.DatTools/DatFileTool.cs
View File

@@ -44,8 +44,8 @@ namespace SabreTools.DatTools
if (datItemFields.Any())
{
// For comparison's sake, we want to use CRC as the base bucketing
datFile.Items.BucketBy(Field.DatItem_CRC, DedupeType.Full);
intDat.Items.BucketBy(Field.DatItem_CRC, DedupeType.None);
datFile.Items.BucketBy(ItemKey.CRC, DedupeType.Full);
intDat.Items.BucketBy(ItemKey.CRC, DedupeType.None);
// Then we do a hashwise comparison against the base DAT
Parallel.ForEach(intDat.Items.Keys, Globals.ParallelOptions, key =>
@@ -74,8 +74,8 @@ namespace SabreTools.DatTools
if (machineFields.Any())
{
// For comparison's sake, we want to use Machine Name as the base bucketing
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.Full);
intDat.Items.BucketBy(Field.Machine_Name, DedupeType.None);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.Full);
intDat.Items.BucketBy(ItemKey.Machine, DedupeType.None);
// Then we do a namewise comparison against the base DAT
Parallel.ForEach(intDat.Items.Keys, Globals.ParallelOptions, key =>
@@ -108,17 +108,17 @@ namespace SabreTools.DatTools
{
// For comparison's sake, we want to use a base ordering
if (useGames)
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None);
else
datFile.Items.BucketBy(Field.DatItem_CRC, DedupeType.None);
datFile.Items.BucketBy(ItemKey.CRC, DedupeType.None);
logger.User($"Comparing '{intDat.Header.FileName}' to base DAT");
// For comparison's sake, we want to a the base bucketing
if (useGames)
intDat.Items.BucketBy(Field.Machine_Name, DedupeType.None);
intDat.Items.BucketBy(ItemKey.Machine, DedupeType.None);
else
intDat.Items.BucketBy(Field.DatItem_CRC, DedupeType.Full);
intDat.Items.BucketBy(ItemKey.CRC, DedupeType.Full);
// Then we compare against the base DAT
List<string> keys = intDat.Items.Keys.ToList();
@@ -182,7 +182,7 @@ namespace SabreTools.DatTools
List<DatFile> outDats = new List<DatFile>();
// Ensure the current DatFile is sorted optimally
datFile.Items.BucketBy(Field.DatItem_CRC, DedupeType.None);
datFile.Items.BucketBy(ItemKey.CRC, DedupeType.None);
// Loop through each of the inputs and get or create a new DatData object
InternalStopwatch watch = new InternalStopwatch("Initializing and filling all output DATs");

2
SabreTools.DatTools/DatFromDir.cs
View File

@@ -191,7 +191,7 @@ namespace SabreTools.DatTools
{
// Add the list if it doesn't exist already
Rom rom = new Rom(baseFile);
datFile.Items.Add(rom.GetKey(Field.DatItem_CRC), rom);
datFile.Items.Add(rom.GetKey(ItemKey.CRC), rom);
logger.Verbose($"File added: {Path.GetFileNameWithoutExtension(item)}");
}
else

20
SabreTools.DatTools/Modification.cs
View File

@@ -43,9 +43,9 @@ namespace SabreTools.DatTools
// Bucket and dedupe according to the flag
if (cleaner?.DedupeRoms == DedupeType.Full)
datFile.Items.BucketBy(Field.DatItem_CRC, cleaner.DedupeRoms);
datFile.Items.BucketBy(ItemKey.CRC, cleaner.DedupeRoms);
else if (cleaner?.DedupeRoms == DedupeType.Game)
datFile.Items.BucketBy(Field.Machine_Name, cleaner.DedupeRoms);
datFile.Items.BucketBy(ItemKey.Machine, cleaner.DedupeRoms);
// Process description to machine name
if (cleaner?.DescriptionAsName == true)
@@ -99,7 +99,7 @@ namespace SabreTools.DatTools
try
{
// Bucket by game first
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None);
// Create a new set of mappings based on the items
var machineMap = new Dictionary<string, Dictionary<MachineField, string>>();
@@ -192,7 +192,7 @@ namespace SabreTools.DatTools
// If we're filtering per machine, bucket by machine first
if (perMachine)
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None);
try
{
@@ -415,7 +415,7 @@ namespace SabreTools.DatTools
regions = new List<string>();
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None, norename: true);
// Then we want to get a mapping of all machines to parents
Dictionary<string, List<string>> parents = new Dictionary<string, List<string>>();
@@ -610,7 +610,7 @@ namespace SabreTools.DatTools
logger.User("Creating device non-merged sets from the DAT");
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, mergeroms, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, mergeroms, norename: true);
// Now we want to loop through all of the games and set the correct information
while (AddRomsFromDevices(datFile, false, false)) ;
@@ -630,7 +630,7 @@ namespace SabreTools.DatTools
logger.User("Creating fully non-merged sets from the DAT");
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, mergeroms, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, mergeroms, norename: true);
// Now we want to loop through all of the games and set the correct information
while (AddRomsFromDevices(datFile, true, true)) ;
@@ -654,7 +654,7 @@ namespace SabreTools.DatTools
logger.User("Creating merged sets from the DAT");
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, mergeroms, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, mergeroms, norename: true);
// Now we want to loop through all of the games and set the correct information
AddRomsFromChildren(datFile);
@@ -677,7 +677,7 @@ namespace SabreTools.DatTools
logger.User("Creating non-merged sets from the DAT");
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, mergeroms, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, mergeroms, norename: true);
// Now we want to loop through all of the games and set the correct information
AddRomsFromParent(datFile);
@@ -700,7 +700,7 @@ namespace SabreTools.DatTools
logger.User("Creating split sets from the DAT");
// For sake of ease, the first thing we want to do is bucket by game
datFile.Items.BucketBy(Field.Machine_Name, mergeroms, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, mergeroms, norename: true);
// Now we want to loop through all of the games and set the correct information
RemoveRomsFromChild(datFile);

4
SabreTools.DatTools/Parser.cs
View File

@@ -2,9 +2,9 @@ using System;
using System.IO;
using System.Text.RegularExpressions;
using SabreTools.Core;
using SabreTools.Core.Tools;
using SabreTools.DatFiles;
using SabreTools.DatItems;
using SabreTools.IO;
using SabreTools.Logging;
@@ -93,7 +93,7 @@ namespace SabreTools.DatTools
// If the output type isn't set already, get the internal output type
DatFormat currentPathFormat = GetDatFormat(currentPath);
datFile.Header.DatFormat = datFile.Header.DatFormat == 0 ? currentPathFormat : datFile.Header.DatFormat;
datFile.Items.SetBucketedBy(Field.DatItem_CRC); // Setting this because it can reduce issues later
datFile.Items.SetBucketedBy(ItemKey.CRC); // Setting this because it can reduce issues later
// Now parse the correct type of DAT
try

6
SabreTools.DatTools/Rebuilder.cs
View File

@@ -92,7 +92,7 @@ namespace SabreTools.DatTools
return success;
// Now that we have a list of depots, we want to bucket the input DAT by SHA-1
datFile.Items.BucketBy(Field.DatItem_SHA1, DedupeType.None);
datFile.Items.BucketBy(ItemKey.SHA1, DedupeType.None);
// Then we want to loop through each of the hashes and see if we can rebuild
var keys = datFile.Items.SortedKeys.ToList();
@@ -131,7 +131,7 @@ namespace SabreTools.DatTools
continue;
// Ensure we are sorted correctly (some other calls can change this)
datFile.Items.BucketBy(Field.DatItem_SHA1, DedupeType.None);
datFile.Items.BucketBy(ItemKey.SHA1, DedupeType.None);
// If there are no items in the hash, we continue
if (datFile.Items[hash] == null || datFile.Items[hash].Count == 0)
@@ -390,7 +390,7 @@ namespace SabreTools.DatTools
if (outputFormat == OutputFormat.Folder && datFile.Header.ForcePacking == PackingFlag.Partial)
{
shouldCheck = true;
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None, lower: false);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None, lower: false);
}
// Now loop through the list and rebuild accordingly

86
SabreTools.DatTools/Splitter.cs
View File

@@ -89,54 +89,54 @@ namespace SabreTools.DatTools
/// </summary>
/// <param name="datFile">Current DatFile object to split</param>
/// <returns>Dictionary of Field to DatFile mappings</returns>
public static Dictionary<Field, DatFile> SplitByHash(DatFile datFile)
public static Dictionary<DatItemField, DatFile> SplitByHash(DatFile datFile)
{
// Create each of the respective output DATs
logger.User("Creating and populating new DATs");
// Create the set of field-to-dat mappings
Dictionary<Field, DatFile> fieldDats = new Dictionary<Field, DatFile>();
Dictionary<DatItemField, DatFile> fieldDats = new Dictionary<DatItemField, DatFile>();
// TODO: Can this be made into a loop?
fieldDats[Field.DatItem_Status] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_Status].Header.FileName += " (Nodump)";
fieldDats[Field.DatItem_Status].Header.Name += " (Nodump)";
fieldDats[Field.DatItem_Status].Header.Description += " (Nodump)";
fieldDats[DatItemField.Status] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.Status].Header.FileName += " (Nodump)";
fieldDats[DatItemField.Status].Header.Name += " (Nodump)";
fieldDats[DatItemField.Status].Header.Description += " (Nodump)";
fieldDats[Field.DatItem_SHA512] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_SHA512].Header.FileName += " (SHA-512)";
fieldDats[Field.DatItem_SHA512].Header.Name += " (SHA-512)";
fieldDats[Field.DatItem_SHA512].Header.Description += " (SHA-512)";
fieldDats[DatItemField.SHA512] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.SHA512].Header.FileName += " (SHA-512)";
fieldDats[DatItemField.SHA512].Header.Name += " (SHA-512)";
fieldDats[DatItemField.SHA512].Header.Description += " (SHA-512)";
fieldDats[Field.DatItem_SHA384] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_SHA384].Header.FileName += " (SHA-384)";
fieldDats[Field.DatItem_SHA384].Header.Name += " (SHA-384)";
fieldDats[Field.DatItem_SHA384].Header.Description += " (SHA-384)";
fieldDats[DatItemField.SHA384] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.SHA384].Header.FileName += " (SHA-384)";
fieldDats[DatItemField.SHA384].Header.Name += " (SHA-384)";
fieldDats[DatItemField.SHA384].Header.Description += " (SHA-384)";
fieldDats[Field.DatItem_SHA256] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_SHA256].Header.FileName += " (SHA-256)";
fieldDats[Field.DatItem_SHA256].Header.Name += " (SHA-256)";
fieldDats[Field.DatItem_SHA256].Header.Description += " (SHA-256)";
fieldDats[DatItemField.SHA256] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.SHA256].Header.FileName += " (SHA-256)";
fieldDats[DatItemField.SHA256].Header.Name += " (SHA-256)";
fieldDats[DatItemField.SHA256].Header.Description += " (SHA-256)";
fieldDats[Field.DatItem_SHA1] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_SHA1].Header.FileName += " (SHA-1)";
fieldDats[Field.DatItem_SHA1].Header.Name += " (SHA-1)";
fieldDats[Field.DatItem_SHA1].Header.Description += " (SHA-1)";
fieldDats[DatItemField.SHA1] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.SHA1].Header.FileName += " (SHA-1)";
fieldDats[DatItemField.SHA1].Header.Name += " (SHA-1)";
fieldDats[DatItemField.SHA1].Header.Description += " (SHA-1)";
fieldDats[Field.DatItem_MD5] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_MD5].Header.FileName += " (MD5)";
fieldDats[Field.DatItem_MD5].Header.Name += " (MD5)";
fieldDats[Field.DatItem_MD5].Header.Description += " (MD5)";
fieldDats[DatItemField.MD5] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.MD5].Header.FileName += " (MD5)";
fieldDats[DatItemField.MD5].Header.Name += " (MD5)";
fieldDats[DatItemField.MD5].Header.Description += " (MD5)";
fieldDats[Field.DatItem_CRC] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.DatItem_CRC].Header.FileName += " (CRC)";
fieldDats[Field.DatItem_CRC].Header.Name += " (CRC)";
fieldDats[Field.DatItem_CRC].Header.Description += " (CRC)";
fieldDats[DatItemField.CRC] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.CRC].Header.FileName += " (CRC)";
fieldDats[DatItemField.CRC].Header.Name += " (CRC)";
fieldDats[DatItemField.CRC].Header.Description += " (CRC)";
fieldDats[Field.NULL] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[Field.NULL].Header.FileName += " (Other)";
fieldDats[Field.NULL].Header.Name += " (Other)";
fieldDats[Field.NULL].Header.Description += " (Other)";
fieldDats[DatItemField.NULL] = DatFile.Create(datFile.Header.CloneStandard());
fieldDats[DatItemField.NULL].Header.FileName += " (Other)";
fieldDats[DatItemField.NULL].Header.Name += " (Other)";
fieldDats[DatItemField.NULL].Header.Description += " (Other)";
// Now populate each of the DAT objects in turn
Parallel.ForEach(datFile.Items.Keys, Globals.ParallelOptions, key =>
@@ -152,26 +152,26 @@ namespace SabreTools.DatTools
if ((item.ItemType == ItemType.Rom && (item as Rom).ItemStatus == ItemStatus.Nodump)
|| (item.ItemType == ItemType.Disk && (item as Disk).ItemStatus == ItemStatus.Nodump))
{
fieldDats[Field.DatItem_Status].Items.Add(key, item);
fieldDats[DatItemField.Status].Items.Add(key, item);
}
// If the file has a SHA-512
else if ((item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).SHA512)))
{
fieldDats[Field.DatItem_SHA512].Items.Add(key, item);
fieldDats[DatItemField.SHA512].Items.Add(key, item);
}
// If the file has a SHA-384
else if ((item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).SHA384)))
{
fieldDats[Field.DatItem_SHA384].Items.Add(key, item);
fieldDats[DatItemField.SHA384].Items.Add(key, item);
}
// If the file has a SHA-256
else if ((item.ItemType == ItemType.Media && !string.IsNullOrWhiteSpace((item as Media).SHA256))
|| (item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).SHA256)))
{
fieldDats[Field.DatItem_SHA256].Items.Add(key, item);
fieldDats[DatItemField.SHA256].Items.Add(key, item);
}
// If the file has a SHA-1
@@ -179,7 +179,7 @@ namespace SabreTools.DatTools
|| (item.ItemType == ItemType.Media && !string.IsNullOrWhiteSpace((item as Media).SHA1))
|| (item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).SHA1)))
{
fieldDats[Field.DatItem_SHA1].Items.Add(key, item);
fieldDats[DatItemField.SHA1].Items.Add(key, item);
}
// If the file has an MD5
@@ -187,18 +187,18 @@ namespace SabreTools.DatTools
|| (item.ItemType == ItemType.Media && !string.IsNullOrWhiteSpace((item as Media).MD5))
|| (item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).MD5)))
{
fieldDats[Field.DatItem_MD5].Items.Add(key, item);
fieldDats[DatItemField.MD5].Items.Add(key, item);
}
// If the file has a CRC
else if ((item.ItemType == ItemType.Rom && !string.IsNullOrWhiteSpace((item as Rom).CRC)))
{
fieldDats[Field.DatItem_CRC].Items.Add(key, item);
fieldDats[DatItemField.CRC].Items.Add(key, item);
}
else
{
fieldDats[Field.NULL].Items.Add(key, item);
fieldDats[DatItemField.NULL].Items.Add(key, item);
}
}
});
@@ -217,7 +217,7 @@ namespace SabreTools.DatTools
public static bool SplitByLevel(DatFile datFile, string outDir, bool shortname, bool basedat)
{
// First, bucket by games so that we can do the right thing
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None, lower: false, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None, lower: false, norename: true);
// Create a temporary DAT to add things to
DatFile tempDat = DatFile.Create(datFile.Header);

4
SabreTools.DatTools/Statistics.cs
View File

@@ -4,8 +4,8 @@ using System.IO;
using System.Linq;
using System.Net;
using SabreTools.Core;
using SabreTools.DatFiles;
using SabreTools.DatItems;
using SabreTools.IO;
using SabreTools.Logging;
using SabreTools.Reports;
@@ -107,7 +107,7 @@ namespace SabreTools.DatTools
logger.Verbose($"Beginning stat collection for '{file.CurrentPath}'");
List<string> games = new List<string>();
DatFile datdata = Parser.CreateAndParse(file.CurrentPath);
datdata.Items.BucketBy(Field.Machine_Name, DedupeType.None, norename: true);
datdata.Items.BucketBy(ItemKey.Machine, DedupeType.None, norename: true);
// Output single DAT stats (if asked)
logger.User($"Adding stats for file '{file.CurrentPath}'\n");

8
SabreTools.DatTools/Verification.cs
View File

@@ -53,7 +53,7 @@ namespace SabreTools.DatTools
return success;
// Now that we have a list of depots, we want to bucket the input DAT by SHA-1
datFile.Items.BucketBy(Field.DatItem_SHA1, DedupeType.None);
datFile.Items.BucketBy(ItemKey.SHA1, DedupeType.None);
// Then we want to loop through each of the hashes and see if we can rebuild
var keys = datFile.Items.SortedKeys.ToList();
@@ -118,11 +118,11 @@ namespace SabreTools.DatTools
bool success = true;
// Force bucketing according to the flags
datFile.Items.SetBucketedBy(Field.NULL);
datFile.Items.SetBucketedBy(ItemKey.NULL);
if (hashOnly)
datFile.Items.BucketBy(Field.DatItem_CRC, DedupeType.Full);
datFile.Items.BucketBy(ItemKey.CRC, DedupeType.Full);
else
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.Full);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.Full);
// Then mark items for removal
var keys = datFile.Items.SortedKeys.ToList();

5
SabreTools.DatTools/Writer.cs
View File

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
using SabreTools.Core;
using SabreTools.DatFiles;
using SabreTools.DatItems;
using SabreTools.IO;
using SabreTools.Logging;
using SabreTools.Reports;
@@ -62,7 +63,7 @@ namespace SabreTools.DatTools
EnsureHeaderFields(datFile);
// Bucket roms by game name, if not already
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None);
// Output the number of items we're going to be writing
logger.User($"A total of {datFile.Items.TotalCount - datFile.Items.RemovedCount} items will be written out to '{datFile.Header.FileName}'");
@@ -107,7 +108,7 @@ namespace SabreTools.DatTools
if (datFile.Items.RomCount + datFile.Items.DiskCount == 0)
datFile.Items.RecalculateStats();
datFile.Items.BucketBy(Field.Machine_Name, DedupeType.None, norename: true);
datFile.Items.BucketBy(ItemKey.Machine, DedupeType.None, norename: true);
var consoleOutput = BaseReport.Create(StatReportFormat.None, null, true, true);
consoleOutput.ReplaceStatistics(datFile.Header.FileName, datFile.Items.Keys.Count(), datFile.Items);