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
Files
41063921f25957e3ba4e5f2bb5a2adc3ae0f0b6e
SabreTools/SabreHelper/RomManipulation.cs

914 lines
29 KiB
C#
Raw Normal View History

Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
using System;
using System.Collections.Generic;
Add stage 1 changes for better merging The new merging process is both parse and merge in one step using an in-memory database. The next steps are to get the data in this database and write it out properly.
2016-04-27 00:53:15 -07:00
using Mono.Data.Sqlite;
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
using System.IO;
Get diff of two rom sets
2016-04-19 15:41:06 -07:00
using System.Linq;
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
using System.Text.RegularExpressions;
using System.Xml;
namespace SabreTools.Helper
{
public class RomManipulation
{
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
// 0-byte file constants
Even more fun with zero-byte files
2016-05-06 13:12:00 -07:00
public static long SizeZero = 0;
public static string CRCZero = "00000000";
public static string MD5Zero = "d41d8cd98f00b204e9800998ecf8427e";
public static string SHA1Zero = "da39a3ee5e6b4b0d3255bfef95601890afd80709";
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
Get diff of two rom sets
2016-04-19 15:41:06 -07:00
/// <summary>
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
/// Get what type of DAT the input file is
Get diff of two rom sets
2016-04-19 15:41:06 -07:00
/// </summary>
/// <param name="filename">Name of the file to be parsed</param>
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
/// <returns>The OutputFormat corresponding to the DAT</returns>
public static OutputFormat GetOutputFormat(string filename)
Get diff of two rom sets
2016-04-19 15:41:06 -07:00
{
try
{
Add lazy evaluation of XML status
2016-04-25 00:25:08 -07:00
StreamReader sr = new StreamReader(File.OpenRead(filename));
string first = sr.ReadLine();
sr.Close();
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
if (first.Contains("<") && first.Contains(">"))
Add DAT name prefixing
2016-04-20 15:30:56 -07:00
{
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
return OutputFormat.Xml;
Add DAT name prefixing
2016-04-20 15:30:56 -07:00
}
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
else if (first.Contains("[") && first.Contains("]"))
Add DAT name prefixing
2016-04-20 15:30:56 -07:00
{
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
return OutputFormat.RomCenter;
}
else
{
return OutputFormat.ClrMamePro;
Add DAT name prefixing
2016-04-20 15:30:56 -07:00
}
}
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
catch (Exception)
Add DAT name prefixing
2016-04-20 15:30:56 -07:00
{
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
return OutputFormat.ClrMamePro;
Slight code consolodation
2016-04-20 15:37:49 -07:00
}
}
Add retrieval of XmlTextReader
2016-04-25 00:26:19 -07:00
/// <summary>
/// Get the XmlTextReader associated with a file, if possible
/// </summary>
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="logger">Logger object for console and file output</param>
/// <returns>The XmlTextReader representing the (possibly converted) file, null otherwise</returns>
public static XmlTextReader GetXmlTextReader(string filename, Logger logger)
{
Improve logging and Nodump handling
2016-05-18 16:37:39 -07:00
logger.Log("Attempting to read file: \"" + filename + "\"");
Add retrieval of XmlTextReader
2016-04-25 00:26:19 -07:00
// Check if file exists
if (!File.Exists(filename))
{
logger.Warning("File '" + filename + "' could not read from!");
return null;
}
Remove most of the outdated references and methods
2016-05-16 20:51:05 -07:00
XmlTextReader xtr;
StringReader sr;
switch (GetOutputFormat(filename))
{
case OutputFormat.Xml:
logger.Log("XML DAT detected");
xtr = new XmlTextReader(filename);
break;
case OutputFormat.RomCenter:
logger.Log("RomCenter DAT detected");
sr = new StringReader(Converters.RomCenterToXML(File.ReadAllLines(filename)).ToString());
xtr = new XmlTextReader(sr);
break;
default:
logger.Log("ClrMamePro DAT detected");
sr = new StringReader(Converters.ClrMameProToXML(File.ReadAllLines(filename)).ToString());
xtr = new XmlTextReader(sr);
break;
}
xtr.WhitespaceHandling = WhitespaceHandling.None;
xtr.DtdProcessing = DtdProcessing.Ignore;
return xtr;
Fix outputted DAT information
2016-04-21 14:35:11 -07:00
}
Add stage 1 changes for better merging The new merging process is both parse and merge in one step using an in-memory database. The next steps are to get the data in this database and write it out properly.
2016-04-27 00:53:15 -07:00
/// <summary>
More changes using DatData objects
2016-05-16 13:42:21 -07:00
/// Parse a DAT and return all found games and roms within
/// </summary>
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="sysid">System ID for the DAT</param>
/// <param name="srcid">Source ID for the DAT</param>
/// <param name="datdata">The DatData object representing found roms to this point</param>
/// <param name="logger">Logger object for console and/or file output</param>
/// <returns>DatData object representing the read-in data</returns>
SabreDAT! This commit creates output that is compatible with the new SabreDAT format, created by me and inspired by Logiqx XML DATs and the SuperDAT format. It uses a file-folder structure instead of rom-game structure, making it more versitile. It still cannot be read in currently, though it would be read in as a SuperDAT since it is the closest equivalent (so all non-file paths will be part of the game). Also, finding which type of XML DAT it is will be a bit difficult, so detection will have to improve.
2016-05-18 22:22:49 -07:00
public static DatData Parse(string filename, int sysid, int srcid, DatData datdata, Logger logger, bool keep = false)
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
{
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
// Prepare all internal variables
XmlReader subreader, headreader, flagreader;
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
bool superdat = false, shouldbreak = false, nodump = false, empty = true;
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
string key = "", crc = "", md5 = "", sha1 = "";
long size = -1;
List<string> parent = new List<string>();
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
XmlTextReader xtr = GetXmlTextReader(filename, logger);
if (xtr != null)
{
xtr.MoveToContent();
while (xtr.NodeType != XmlNodeType.None)
{
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
// If we're ending a folder or game, take care of possibly empty games and removing from the parent
if (xtr.NodeType == XmlNodeType.EndElement && (xtr.Name == "directory" || xtr.Name == "dir"))
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
{
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
// If we didn't find any items in the folder, make sure to add the blank rom
if (empty)
Slight tweak to accommodate RV Dir2DAT
2016-05-19 09:30:38 -07:00
{
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
RomData rom = new RomData
{
Name = "null",
Game = String.Join("\\", parent),
Size = -1,
CRC = "null",
MD5 = "null",
SHA1 = "null",
};
key = rom.Size + "-" + rom.CRC;
if (datdata.Roms.ContainsKey(key))
{
datdata.Roms[key].Add(rom);
}
else
{
List<RomData> temp = new List<RomData>();
temp.Add(rom);
datdata.Roms.Add(key, temp);
}
}
// Regardless, end the current folder
empty = true;
// If we have an end folder element, remove one item from the parent, if possible
if (parent.Count > 0)
{
parent.RemoveAt(parent.Count - 1);
if (keep)
{
datdata.Type = (String.IsNullOrEmpty(datdata.Type) ? "SuperDAT" : datdata.Type);
}
Slight tweak to accommodate RV Dir2DAT
2016-05-19 09:30:38 -07:00
}
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
}
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
// We only want elements
if (xtr.NodeType != XmlNodeType.Element)
{
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
if (xtr.Read())
{
continue;
}
break;
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
}
switch (xtr.Name)
{
case "header":
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
// We want to process the entire subtree of the header
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
headreader = xtr.ReadSubtree();
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
if (headreader != null)
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
{
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
while (!headreader.EOF)
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
{
// We only want elements
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
if (headreader.NodeType != XmlNodeType.Element || headreader.Name == "header")
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
{
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
headreader.Read();
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
continue;
}
// Get all header items (ONLY OVERWRITE IF THERE'S NO DATA)
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
string content = "";
switch (headreader.Name)
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
{
case "name":
More SuperDAT improvments
2016-05-17 16:53:02 -07:00
content = headreader.ReadElementContentAsString(); ;
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Name = (String.IsNullOrEmpty(datdata.Name) ? content : datdata.Name);
More SuperDAT improvments
2016-05-17 16:53:02 -07:00
superdat = superdat || content.Contains(" - SuperDAT");
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
if (keep)
{
datdata.Type = (String.IsNullOrEmpty(datdata.Type) ? "SuperDAT" : datdata.Type);
}
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "description":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Description = (String.IsNullOrEmpty(datdata.Description) ? content : datdata.Description);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "category":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Category = (String.IsNullOrEmpty(datdata.Category) ? content : datdata.Category);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "version":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Version = (String.IsNullOrEmpty(datdata.Version) ? content : datdata.Version);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "date":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Date = (String.IsNullOrEmpty(datdata.Date) ? content : datdata.Date);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "author":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Author = (String.IsNullOrEmpty(datdata.Author) ? content : datdata.Author);
// Special cases for SabreDAT
datdata.Email = (String.IsNullOrEmpty(datdata.Email) && !String.IsNullOrEmpty(headreader.GetAttribute("email")) ?
headreader.GetAttribute("email") : datdata.Email);
datdata.Homepage = (String.IsNullOrEmpty(datdata.Homepage) && !String.IsNullOrEmpty(headreader.GetAttribute("homepage")) ?
headreader.GetAttribute("homepage") : datdata.Email);
datdata.Url = (String.IsNullOrEmpty(datdata.Url) && !String.IsNullOrEmpty(headreader.GetAttribute("url")) ?
headreader.GetAttribute("url") : datdata.Email);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "email":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Email = (String.IsNullOrEmpty(datdata.Email) ? content : datdata.Email);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "homepage":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Homepage = (String.IsNullOrEmpty(datdata.Homepage) ? content : datdata.Homepage);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "url":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Url = (String.IsNullOrEmpty(datdata.Url) ? content : datdata.Url);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
case "comment":
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Comment = (String.IsNullOrEmpty(datdata.Comment) ? content : datdata.Comment);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
More SuperDAT improvments
2016-05-17 16:53:02 -07:00
case "type":
content = headreader.ReadElementContentAsString();
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
datdata.Type = (String.IsNullOrEmpty(datdata.Type) ? content : datdata.Type);
More SuperDAT improvments
2016-05-17 16:53:02 -07:00
superdat = superdat || content.Contains("SuperDAT");
break;
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
case "clrmamepro":
if (headreader.GetAttribute("forcemerging") != null)
{
switch (headreader.GetAttribute("forcemerging"))
{
case "split":
datdata.ForceMerging = ForceMerging.Split;
break;
case "none":
datdata.ForceMerging = ForceMerging.None;
break;
case "full":
datdata.ForceMerging = ForceMerging.Full;
break;
}
}
if (headreader.GetAttribute("forcenodump") != null)
{
switch (headreader.GetAttribute("forcenodump"))
{
case "obsolete":
datdata.ForceNodump = ForceNodump.Obsolete;
break;
case "required":
datdata.ForceNodump = ForceNodump.Required;
break;
case "ignore":
datdata.ForceNodump = ForceNodump.Ignore;
break;
}
}
if (headreader.GetAttribute("forcepacking") != null)
{
switch (headreader.GetAttribute("forcepacking"))
{
case "zip":
datdata.ForcePacking = ForcePacking.Zip;
break;
case "unzip":
datdata.ForcePacking = ForcePacking.Unzip;
break;
}
}
Use superior DAT creation tools instead of direct DAT conversion. This change includes a few changes meant to keep the information from each DAT and have it retained in a single object which can then be written out in any format or added to other DATs with very little issue. This new system is much more versitile since all it needs is a way to convert each DAT to XML and then use the built-in output to output from the XML to the target format. This also gives the ability to clean a DAT by "converting" a DAT to the same format, removing any improper tagging or the such.
2016-05-16 15:17:11 -07:00
headreader.Read();
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
break;
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
case "flags":
flagreader = xtr.ReadSubtree();
if (flagreader != null)
{
while (!flagreader.EOF)
{
// We only want elements
if (flagreader.NodeType != XmlNodeType.Element || flagreader.Name == "flags")
{
flagreader.Read();
continue;
}
switch (flagreader.Name)
{
case "flag":
if (flagreader.GetAttribute("name") != null && flagreader.GetAttribute("value") != null)
{
content = flagreader.GetAttribute("value");
switch (flagreader.GetAttribute("name"))
{
case "type":
datdata.Type = (datdata.Type == "" ? content : datdata.Type);
superdat = superdat || content.Contains("SuperDAT");
break;
case "forcemerging":
switch (content)
{
case "split":
datdata.ForceMerging = ForceMerging.Split;
break;
case "none":
datdata.ForceMerging = ForceMerging.None;
break;
case "full":
datdata.ForceMerging = ForceMerging.Full;
break;
}
break;
case "forcenodump":
switch (content)
{
case "obsolete":
datdata.ForceNodump = ForceNodump.Obsolete;
break;
case "required":
datdata.ForceNodump = ForceNodump.Required;
break;
case "ignore":
datdata.ForceNodump = ForceNodump.Ignore;
break;
}
break;
case "forcepacking":
switch (content)
{
case "zip":
datdata.ForcePacking = ForcePacking.Zip;
break;
case "unzip":
datdata.ForcePacking = ForcePacking.Unzip;
break;
}
break;
}
}
flagreader.Read();
break;
default:
flagreader.Read();
break;
}
}
}
headreader.Skip();
break;
Fix reading from nonstandard headers
2016-05-16 22:25:03 -07:00
default:
headreader.Read();
break;
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
}
}
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
}
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
// Skip the header node now that we've processed it
xtr.Skip();
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
break;
case "machine":
case "game":
case "software":
string temptype = xtr.Name;
string tempname = "";
// We want to process the entire subtree of the game
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
subreader = xtr.ReadSubtree();
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
if (subreader != null)
{
if (temptype == "software" && subreader.ReadToFollowing("description"))
{
tempname = subreader.ReadElementContentAsString();
Descriptions might have forward slashes that AREN'T folder markers. Replace them with underscores.
2016-05-18 17:10:20 -07:00
tempname = tempname.Replace('/', '_');
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
}
else
{
// There are rare cases where a malformed XML will not have the required attributes. We can only skip them.
if (xtr.AttributeCount == 0)
{
logger.Error("No attributes were found");
xtr.ReadToNextSibling(xtr.Name);
continue;
}
tempname = xtr.GetAttribute("name");
}
SabreDAT! This commit creates output that is compatible with the new SabreDAT format, created by me and inspired by Logiqx XML DATs and the SuperDAT format. It uses a file-folder structure instead of rom-game structure, making it more versitile. It still cannot be read in currently, though it would be read in as a SuperDAT since it is the closest equivalent (so all non-file paths will be part of the game). Also, finding which type of XML DAT it is will be a bit difficult, so detection will have to improve.
2016-05-18 22:22:49 -07:00
if (superdat && !keep)
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
{
tempname = Regex.Match(tempname, @".*?\\(.*)").Groups[1].Value;
}
Slight tweak to accommodate RV Dir2DAT
2016-05-19 09:30:38 -07:00
// Get the name of the game from the parent
else if (superdat && keep && parent.Count > 0)
{
tempname = String.Join("\\", parent) + "\\" + tempname;
}
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
while (subreader.Read())
{
// We only want elements
if (subreader.NodeType != XmlNodeType.Element)
{
continue;
}
// Get the roms from the machine
switch (subreader.Name)
{
case "rom":
case "disk":
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
empty = false;
Let's support Nodumps for output as well
2016-05-18 16:59:34 -07:00
// If the rom is nodump, flag it
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
nodump = false;
Add skip on nodump
2016-05-06 10:59:05 -07:00
if (xtr.GetAttribute("flags") == "nodump" || xtr.GetAttribute("status") == "nodump")
{
Improve logging and Nodump handling
2016-05-18 16:37:39 -07:00
logger.Log("Nodump detected: " +
Let's support Nodumps for output as well
2016-05-18 16:59:34 -07:00
(xtr.GetAttribute("name") != null && xtr.GetAttribute("name") != "" ? "\"" + xtr.GetAttribute("name") + "\"" : "ROM NAME NOT FOUND"));
nodump = true;
Add skip on nodump
2016-05-06 10:59:05 -07:00
}
dataarea didn't work, let's try offset
2016-05-14 19:41:07 -07:00
// Take care of hex-sized files
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
size = -1;
dataarea didn't work, let's try offset
2016-05-14 19:41:07 -07:00
if (xtr.GetAttribute("size") != null && xtr.GetAttribute("size").Contains("0x"))
{
size = Convert.ToInt64(xtr.GetAttribute("size"), 16);
}
else if (xtr.GetAttribute("size") != null)
{
Int64.TryParse(xtr.GetAttribute("size"), out size);
}
Implement continue/ignore flag for software lists
2016-05-15 13:23:29 -07:00
// If the rom is continue or ignore, add the size to the previous rom
if (xtr.GetAttribute("loadflag") == "continue" || xtr.GetAttribute("loadflag") == "ignore")
dataarea didn't work, let's try offset
2016-05-14 19:41:07 -07:00
{
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
int index = datdata.Roms[key].Count() - 1;
RomData lastrom = datdata.Roms[key][index];
Implement continue/ignore flag for software lists
2016-05-15 13:23:29 -07:00
lastrom.Size += size;
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
datdata.Roms[key].RemoveAt(index);
datdata.Roms[key].Add(lastrom);
Implement continue/ignore flag for software lists
2016-05-15 13:23:29 -07:00
continue;
dataarea didn't work, let's try offset
2016-05-14 19:41:07 -07:00
}
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
Fix "-" crc, md5, and sha1 hashes
2016-05-06 10:53:42 -07:00
// Sanitize the hashes from null, hex sizes, and "true blank" strings
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
crc = (xtr.GetAttribute("crc") != null ? xtr.GetAttribute("crc").ToLowerInvariant().Trim() : "");
Forgot the other Parse
2016-05-02 14:08:50 -07:00
crc = (crc.StartsWith("0x") ? crc.Remove(0, 2) : crc);
Fix "-" crc, md5, and sha1 hashes
2016-05-06 10:53:42 -07:00
crc = (crc == "-" ? "" : crc);
Some hex hashes are short and need to be padded
2016-05-10 18:20:27 -07:00
crc = (crc == "" ? "" : crc.PadLeft(8, '0'));
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
md5 = (xtr.GetAttribute("md5") != null ? xtr.GetAttribute("md5").ToLowerInvariant().Trim() : "");
Forgot the other Parse
2016-05-02 14:08:50 -07:00
md5 = (md5.StartsWith("0x") ? md5.Remove(0, 2) : md5);
Fix "-" crc, md5, and sha1 hashes
2016-05-06 10:53:42 -07:00
md5 = (md5 == "-" ? "" : md5);
Some hex hashes are short and need to be padded
2016-05-10 18:20:27 -07:00
md5 = (md5 == "" ? "" : md5.PadLeft(32, '0'));
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
sha1 = (xtr.GetAttribute("sha1") != null ? xtr.GetAttribute("sha1").ToLowerInvariant().Trim() : "");
Forgot the other Parse
2016-05-02 14:08:50 -07:00
sha1 = (sha1.StartsWith("0x") ? sha1.Remove(0, 2) : sha1);
Fix "-" crc, md5, and sha1 hashes
2016-05-06 10:53:42 -07:00
sha1 = (sha1 == "-" ? "" : sha1);
Some hex hashes are short and need to be padded
2016-05-10 18:20:27 -07:00
sha1 = (sha1 == "" ? "" : sha1.PadLeft(40, '0'));
Forgot the other Parse
2016-05-02 14:08:50 -07:00
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
// If we have a rom and it's missing size AND the hashes match a 0-byte file, fill in the rest of the info
Fix odd output naming for conversion dats
2016-05-18 15:34:49 -07:00
if (subreader.Name == "rom" && (size == 0 || size == -1) && ((crc == CRCZero || crc == "") || md5 == MD5Zero || sha1 == SHA1Zero))
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
{
Even more fun with zero-byte files
2016-05-06 13:12:00 -07:00
size = SizeZero;
crc = CRCZero;
md5 = MD5Zero;
sha1 = SHA1Zero;
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
}
// If the file has no size and it's not the above case, skip and log
Even more fun with zero-byte files
2016-05-06 13:12:00 -07:00
else if (subreader.Name == "rom" && (size == 0 || size == -1))
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
{
Change an Error back to Warning
2016-05-18 20:12:58 -07:00
logger.Warning("Incomplete entry for \"" + xtr.GetAttribute("name") + "\" will be output as nodump");
Let's support Nodumps for output as well
2016-05-18 16:59:34 -07:00
nodump = true;
More 0-byte file shennanigans
2016-05-06 12:56:02 -07:00
}
Add skip on nodump
2016-05-06 10:59:05 -07:00
// Only add the rom if there's useful information in it
Let's support Nodumps for output as well
2016-05-18 16:59:34 -07:00
if (!(crc == "" && md5 == "" && sha1 == "") || nodump)
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
{
log if disk is found because some tools don't like it I dunno, ask Obiwantje...
2016-05-18 17:06:13 -07:00
// If we got to this point and it's a disk, log it because some tools don't like disks
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
if (subreader.Name == "disk")
log if disk is found because some tools don't like it I dunno, ask Obiwantje...
2016-05-18 17:06:13 -07:00
{
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
logger.Log("Disk found: \"" + subreader.GetAttribute("name") + "\"");
log if disk is found because some tools don't like it I dunno, ask Obiwantje...
2016-05-18 17:06:13 -07:00
}
Add skip on nodump
2016-05-06 10:59:05 -07:00
// Get the new values to add
Consolodate the key variables since there's no need for separate ones.
2016-05-15 13:45:41 -07:00
key = size + "-" + crc;
Change merging because blank CRCs can lead to problems
2016-05-11 15:02:33 -07:00
Add skip on nodump
2016-05-06 10:59:05 -07:00
RomData value = new RomData
{
Game = tempname,
Name = xtr.GetAttribute("name"),
Type = xtr.Name,
SystemID = sysid,
SourceID = srcid,
Size = size,
CRC = crc,
MD5 = md5,
SHA1 = sha1,
System = filename,
Let's support Nodumps for output as well
2016-05-18 16:59:34 -07:00
Nodump = nodump,
Add skip on nodump
2016-05-06 10:59:05 -07:00
};
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
if (datdata.Roms.ContainsKey(key))
Add skip on nodump
2016-05-06 10:59:05 -07:00
{
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
datdata.Roms[key].Add(value);
Add skip on nodump
2016-05-06 10:59:05 -07:00
}
else
{
List<RomData> newvalue = new List<RomData>();
newvalue.Add(value);
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
datdata.Roms.Add(key, newvalue);
Add skip on nodump
2016-05-06 10:59:05 -07:00
}
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
}
break;
}
}
}
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
// If we didn't find any items in the folder, make sure to add the blank rom
if (empty)
{
tempname = (parent.Count > 0 ? String.Join("\\", parent) + Path.DirectorySeparatorChar : "") + tempname;
RomData rom = new RomData
{
Name = "null",
Game = tempname,
Size = -1,
CRC = "null",
MD5 = "null",
SHA1 = "null",
};
key = rom.Size + "-" + rom.CRC;
if (datdata.Roms.ContainsKey(key))
{
datdata.Roms[key].Add(rom);
}
else
{
List<RomData> temp = new List<RomData>();
temp.Add(rom);
datdata.Roms.Add(key, temp);
}
}
// Regardless, end the current folder
empty = true;
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
// Read to next game
if (!xtr.ReadToNextSibling(temptype))
{
shouldbreak = true;
}
break;
Slight tweak to accommodate RV Dir2DAT
2016-05-19 09:30:38 -07:00
case "dir":
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
case "directory":
// Set SuperDAT flag for all SabreDAT inputs, regardless of depth
superdat = true;
if (keep)
{
datdata.Type = (datdata.Type == "" ? "SuperDAT" : datdata.Type);
}
string foldername = (xtr.GetAttribute("name") == null ? "" : xtr.GetAttribute("name"));
if (foldername != "")
{
parent.Add(foldername);
}
xtr.Read();
break;
case "file":
Handle blank folders in DATFromDir and output alike
2016-05-19 10:28:53 -07:00
empty = false;
Enable SabreDAT read-in and fix output Additionally, fix the necessity for blank strings in DatData definitions for read-in. Now if it's null it'll try writing to it as well.
2016-05-18 23:51:54 -07:00
// If the rom is nodump, flag it
nodump = false;
flagreader = xtr.ReadSubtree();
if (flagreader != null)
{
while (!flagreader.EOF)
{
// We only want elements
if (flagreader.NodeType != XmlNodeType.Element || flagreader.Name == "flags")
{
flagreader.Read();
continue;
}
switch (flagreader.Name)
{
case "flag":
case "status":
if (flagreader.GetAttribute("name") != null && flagreader.GetAttribute("value") != null)
{
string content = flagreader.GetAttribute("value");
switch (flagreader.GetAttribute("name"))
{
case "nodump":
logger.Log("Nodump detected: " + (xtr.GetAttribute("name") != null && xtr.GetAttribute("name") != "" ?
"\"" + xtr.GetAttribute("name") + "\"" : "ROM NAME NOT FOUND"));
nodump = true;
break;
}
}
break;
}
flagreader.Read();
}
}
// Take care of hex-sized files
size = -1;
if (xtr.GetAttribute("size") != null && xtr.GetAttribute("size").Contains("0x"))
{
size = Convert.ToInt64(xtr.GetAttribute("size"), 16);
}
else if (xtr.GetAttribute("size") != null)
{
Int64.TryParse(xtr.GetAttribute("size"), out size);
}
// If the rom is continue or ignore, add the size to the previous rom
if (xtr.GetAttribute("loadflag") == "continue" || xtr.GetAttribute("loadflag") == "ignore")
{
int index = datdata.Roms[key].Count() - 1;
RomData lastrom = datdata.Roms[key][index];
lastrom.Size += size;
datdata.Roms[key].RemoveAt(index);
datdata.Roms[key].Add(lastrom);
continue;
}
// Sanitize the hashes from null, hex sizes, and "true blank" strings
crc = (xtr.GetAttribute("crc") != null ? xtr.GetAttribute("crc").ToLowerInvariant().Trim() : "");
crc = (crc.StartsWith("0x") ? crc.Remove(0, 2) : crc);
crc = (crc == "-" ? "" : crc);
crc = (crc == "" ? "" : crc.PadLeft(8, '0'));
md5 = (xtr.GetAttribute("md5") != null ? xtr.GetAttribute("md5").ToLowerInvariant().Trim() : "");
md5 = (md5.StartsWith("0x") ? md5.Remove(0, 2) : md5);
md5 = (md5 == "-" ? "" : md5);
md5 = (md5 == "" ? "" : md5.PadLeft(32, '0'));
sha1 = (xtr.GetAttribute("sha1") != null ? xtr.GetAttribute("sha1").ToLowerInvariant().Trim() : "");
sha1 = (sha1.StartsWith("0x") ? sha1.Remove(0, 2) : sha1);
sha1 = (sha1 == "-" ? "" : sha1);
sha1 = (sha1 == "" ? "" : sha1.PadLeft(40, '0'));
// If we have a rom and it's missing size AND the hashes match a 0-byte file, fill in the rest of the info
if (xtr.GetAttribute("type") == "rom" && (size == 0 || size == -1) && ((crc == CRCZero || crc == "") || md5 == MD5Zero || sha1 == SHA1Zero))
{
size = SizeZero;
crc = CRCZero;
md5 = MD5Zero;
sha1 = SHA1Zero;
}
// If the file has no size and it's not the above case, skip and log
else if (xtr.GetAttribute("type") == "rom" && (size == 0 || size == -1))
{
logger.Warning("Incomplete entry for \"" + xtr.GetAttribute("name") + "\" will be output as nodump");
nodump = true;
}
// Get the name of the game from the parent
tempname = String.Join("\\", parent);
// If we have a SuperDAT and we aren't keeping names
if (superdat && !keep)
{
tempname = Regex.Match(tempname, @".*?\\(.*)").Groups[1].Value;
}
// Only add the rom if there's useful information in it
if (!(crc == "" && md5 == "" && sha1 == "") || nodump)
{
// If we got to this point and it's a disk, log it because some tools don't like disks
if (xtr.GetAttribute("type") == "disk")
{
logger.Log("Disk found: \"" + xtr.GetAttribute("name") + "\"");
}
// Get the new values to add
key = size + "-" + crc;
RomData value = new RomData
{
Game = tempname,
Name = xtr.GetAttribute("name"),
Type = xtr.GetAttribute("type"),
SystemID = sysid,
SourceID = srcid,
Size = size,
CRC = crc,
MD5 = md5,
SHA1 = sha1,
System = filename,
Nodump = nodump,
};
if (datdata.Roms.ContainsKey(key))
{
datdata.Roms[key].Add(value);
}
else
{
List<RomData> newvalue = new List<RomData>();
newvalue.Add(value);
datdata.Roms.Add(key, newvalue);
}
}
xtr.Read();
break;
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
default:
xtr.Read();
break;
}
// If we hit an endpoint, break out of the loop early
if (shouldbreak)
{
break;
}
}
}
Use DatData for everything; read header elements Reading the header elements will come in handy for when built-in parse and generate code will take care of converting from any format to any format.
2016-05-16 14:28:23 -07:00
return datdata;
Add dictionary-based Parse for future use
2016-04-28 10:37:33 -07:00
}
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
/// <summary>
/// Merge an arbitrary set of ROMs based on the supplied information
/// </summary>
/// <param name="inroms">List of RomData objects representing the roms to be merged</param>
/// <param name="presorted">True if the list should be considered pre-sorted (default false)</param>
/// <returns>A List of RomData objects representing the merged roms</returns>
public static List<RomData> Merge(List<RomData> inroms, bool presorted = false)
{
List<RomData> outroms = new List<RomData>();
[doc] remove old sorting algorithm because it's not useful anymore
2016-05-13 16:55:58 -07:00
// First sort the roms by size, crc, md5, sha1 (in order), if not sorted already
Second experimental attempt at improving merges
2016-05-13 16:18:50 -07:00
if (!presorted)
{
inroms.Sort(delegate (RomData x, RomData y)
{
if (x.Size == y.Size)
{
if (x.CRC == y.CRC)
{
if (x.MD5 == y.MD5)
{
return String.Compare(x.SHA1, y.SHA1);
}
return String.Compare(x.MD5, y.MD5);
}
return String.Compare(x.CRC, y.CRC);
}
return (int)(x.Size - y.Size);
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
});
}
// Then, deduplicate them by checking to see if data matches
foreach (RomData rom in inroms)
{
// If it's the first rom in the list, don't touch it
if (outroms.Count != 0)
{
// Check if the rom is a duplicate
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
bool dupefound = false;
RomData savedrom = new RomData();
int pos = -1;
for (int i = 0; i < outroms.Count; i++)
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
RomData lastrom = outroms[i];
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
if (rom.Type == "rom" && lastrom.Type == "rom")
{
dupefound = ((rom.Size == lastrom.Size) &&
((rom.CRC == "" || lastrom.CRC == "") || rom.CRC == lastrom.CRC) &&
((rom.MD5 == "" || lastrom.MD5 == "") || rom.MD5 == lastrom.MD5) &&
((rom.SHA1 == "" || lastrom.SHA1 == "") || rom.SHA1 == lastrom.SHA1)
);
}
else if (rom.Type == "disk" && lastrom.Type == "disk")
{
dupefound = (((rom.MD5 == "" || lastrom.MD5 == "") || rom.MD5 == lastrom.MD5) &&
((rom.SHA1 == "" || lastrom.SHA1 == "") || rom.SHA1 == lastrom.SHA1)
);
}
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// If it's a duplicate, skip adding it to the output but add any missing information
if (dupefound)
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
savedrom = lastrom;
pos = i;
savedrom.CRC = (savedrom.CRC == "" && rom.CRC != "" ? rom.CRC : savedrom.CRC);
savedrom.MD5 = (savedrom.MD5 == "" && rom.MD5 != "" ? rom.MD5 : savedrom.MD5);
savedrom.SHA1 = (savedrom.SHA1 == "" && rom.SHA1 != "" ? rom.SHA1 : savedrom.SHA1);
// If the duplicate is external already or should be, set it
if (savedrom.Dupe >= DupeType.ExternalHash || savedrom.SystemID != rom.SystemID || savedrom.SourceID != rom.SourceID)
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
if (savedrom.Game == rom.Game && savedrom.Name == rom.Name)
{
savedrom.Dupe = DupeType.ExternalAll;
}
else
{
savedrom.Dupe = DupeType.ExternalHash;
}
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
}
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// Otherwise, it's considered an internal dupe
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
else
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
if (savedrom.Game == rom.Game && savedrom.Name == rom.Name)
{
savedrom.Dupe = DupeType.InternalAll;
}
else
{
savedrom.Dupe = DupeType.InternalHash;
}
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
}
Invert the logic so that it actually makes sense
2016-05-11 12:08:17 -07:00
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// If the current system has a lower ID than the previous, set the system accordingly
if (rom.SystemID < savedrom.SystemID)
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
savedrom.SystemID = rom.SystemID;
savedrom.System = rom.System;
savedrom.Game = rom.Game;
savedrom.Name = rom.Name;
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
}
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// If the current source has a lower ID than the previous, set the source accordingly
if (rom.SourceID < savedrom.SourceID)
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
savedrom.SourceID = rom.SourceID;
savedrom.Source = rom.Source;
savedrom.Game = rom.Game;
savedrom.Name = rom.Name;
An attempt to make diffing work the way I think it should Basically, if a rom is a duplicate, it can be a duplicate within a system or source or across system or source, and by hash alone or by all data matching. The four combinations make an enum now and the diff function is the only one that uses them right now. If we're in dedup mode, we want to check hashes only in diff. Otherwise, we want to check against ones that match all information. This needs field testing.
2016-05-10 20:55:51 -07:00
}
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
break;
Fix diffing
2016-05-17 11:49:09 -07:00
}
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
}
Fix diffing
2016-05-17 11:49:09 -07:00
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// If no duplicate is found, add it to the list
if (!dupefound)
{
outroms.Add(rom);
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
}
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
// Otherwise, if a new rom information is found, add that
..wasn't actually adding the roms
2016-04-19 10:38:01 -07:00
else
{
Make deduping EVEN MORE accurate With thanks to Obiwantje and EliUmniCk for testing and helping with the design update.
2016-05-17 12:55:29 -07:00
outroms.RemoveAt(pos);
outroms.Insert(pos, savedrom);
..wasn't actually adding the roms
2016-04-19 10:38:01 -07:00
}
}
else
{
outroms.Add(rom);
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
}
}
// Then return the result
return outroms;
}
/// <summary>
/// Sort a list of RomData objects by SystemID, SourceID, Game, and Name (in order)
/// </summary>
/// <param name="roms">List of RomData objects representing the roms to be sorted</param>
/// <param name="norename">True if files are not renamed, false otherwise</param>
Reduce the number of steps
2016-04-29 11:49:23 -07:00
/// <returns>True if it sorted correctly, false otherwise</returns>
public static bool Sort(List<RomData> roms, bool norename)
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
{
roms.Sort(delegate (RomData x, RomData y)
{
if (x.SystemID == y.SystemID)
{
if (x.SourceID == y.SourceID)
{
if (x.Game == y.Game)
{
return String.Compare(x.Name, y.Name);
}
return String.Compare(x.Game, y.Game);
}
return (norename ? String.Compare(x.Game, y.Game) : x.SourceID - y.SourceID);
}
return (norename ? String.Compare(x.Game, y.Game) : x.SystemID - y.SystemID);
});
Reduce the number of steps
2016-04-29 11:49:23 -07:00
return true;
Use centralized DAT parsing and manipulate data after Though the change doesn't reflect this, RomManipulation is a renamed Sorting with an addtional method, Parse.
2016-04-19 01:11:23 -07:00
}
}
}
Reference in New Issue Copy Permalink