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

[DATabase, RomManipulation] Wrap Filter into Update

Browse Source
This commit is contained in:
Matt Nadareski
2016-06-11 15:07:53 -07:00
parent 0d12d3bad5
commit c3d6f1d6b8
5 changed files with 274 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
DATabase/DATabase.cs
View File

@@ -586,14 +586,15 @@ namespace SabreTools
ListSystems();
}
// Convert or update a DAT or folder of DATs
else if (update || outputCMP || outputMiss || outputRC || outputSD || outputXML || romba)
// Convert, update, and filter a DAT or folder of DATs
else if (update || outputCMP || outputMiss || outputRC || outputSD || outputXML || romba || filter)
{
foreach (string input in inputs)
{
InitUpdate(input, filename, name, description, category, version, date, author, email, homepage, url, comment, header,
superdat, forcemerge, forcend, forcepack, outputCMP, outputMiss, outputRC, outputSD, outputXML, usegame, prefix,
postfix, quotes, repext, addext, datprefix, romba, tsv, outdir, clean, dedup);
postfix, quotes, repext, addext, datprefix, romba, tsv, gamename, romname, romtype, sgt, slt, seq, crc, md5,
sha1, nodump, outdir, clean, dedup);
}
}
@@ -664,12 +665,6 @@ namespace SabreTools
InitStats(inputs, single);
}
// Filter input files
else if (filter)
{
InitFilter(inputs, outdir, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
// If nothing is set, show the help
else
{

1
DATabase/DATabase.csproj
View File

@@ -105,7 +105,6 @@
</ItemGroup>
<ItemGroup>
<Compile Include="Split.cs" />
<Compile Include="Filter.cs" />
<Compile Include="ImportExport\Generate.cs" />
<Compile Include="ImportExport\GenerateTwo.cs" />
<Compile Include="ImportExport\Import.cs" />

232
DATabase/Filter.cs
View File

@@ -1,232 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using SabreTools.Helper;
namespace SabreTools
{
public class Filter
{
// Private instance variables
private string _filename;
private string _outdir;
private string _gamename;
private string _romname;
private string _romtype;
private long _sgt;
private long _slt;
private long _seq;
private string _crc;
private string _md5;
private string _sha1;
private bool? _nodump;
private Logger _logger;
/// <summary>
/// Create a Filter object
/// </summary>
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="outdir">Output directory to write the file to</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 file and console output</param>
public Filter(string filename, string outdir, string gamename, string romname, string romtype,
long sgt, long slt, long seq, string crc, string md5, string sha1, bool? nodump, Logger logger)
{
_filename = filename;
_outdir = (outdir == "" ? Path.GetDirectoryName(_filename) : outdir);
_gamename = gamename;
_romname = romname;
_romtype = romtype;
_sgt = sgt;
_slt = slt;
_seq = seq;
_crc = crc;
_md5 = md5;
_sha1 = sha1;
_nodump = nodump;
_logger = logger;
}
/// <summary>
/// Process an individual DAT with the given information
/// </summary>
/// <returns>True if the DAT was output, false otherwise</returns>
public bool Process()
{
_logger.User("Processing file: '" + _filename + "'");
// Populated the DAT information
DatData datdata = new DatData();
datdata = RomManipulation.Parse(_filename, 0, 0, datdata, _logger);
// Now loop through and create a new Rom dictionary using filtered values
Dictionary<string, List<RomData>> dict = new Dictionary<string, List<RomData>>();
List<string> keys = datdata.Roms.Keys.ToList();
foreach (string key in keys)
{
List<RomData> roms = datdata.Roms[key];
foreach (RomData rom in roms)
{
// Filter on nodump status
if (_nodump == true && !rom.Nodump)
{
continue;
}
if (_nodump == false && rom.Nodump)
{
continue;
}
// Filter on game name
if (_gamename != "")
{
if (_gamename.StartsWith("*") && _gamename.EndsWith("*") && !rom.Game.ToLowerInvariant().Contains(_gamename.ToLowerInvariant().Replace("*", "")))
{
continue;
}
else if (_gamename.StartsWith("*") && !rom.Game.EndsWith(_gamename.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
else if (_gamename.EndsWith("*") && !rom.Game.StartsWith(_gamename.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
// Filter on rom name
if (_romname != "")
{
if (_romname.StartsWith("*") && _romname.EndsWith("*") && !rom.Name.ToLowerInvariant().Contains(_romname.ToLowerInvariant().Replace("*", "")))
{
continue;
}
else if (_romname.StartsWith("*") && !rom.Name.EndsWith(_romname.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
else if (_romname.EndsWith("*") && !rom.Name.StartsWith(_romname.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
// Filter on rom type
if (_romtype != "" && rom.Type.ToLowerInvariant() != _romtype.ToLowerInvariant())
{
continue;
}
// Filter on rom size
if (_seq != -1 && rom.Size != _seq)
{
continue;
}
else
{
if (_sgt != -1 && rom.Size < _sgt)
{
continue;
}
if (_slt != -1 && rom.Size > _slt)
{
continue;
}
}
// Filter on crc
if (_crc != "")
{
if (_crc.StartsWith("*") && _crc.EndsWith("*") && !rom.CRC.ToLowerInvariant().Contains(_crc.ToLowerInvariant().Replace("*", "")))
{
continue;
}
else if (_crc.StartsWith("*") && !rom.CRC.EndsWith(_crc.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
else if (_crc.EndsWith("*") && !rom.CRC.StartsWith(_crc.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
// Filter on md5
if (_md5 != "")
{
if (_md5.StartsWith("*") && _md5.EndsWith("*") && !rom.MD5.ToLowerInvariant().Contains(_md5.ToLowerInvariant().Replace("*", "")))
{
continue;
}
else if (_md5.StartsWith("*") && !rom.MD5.EndsWith(_md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
else if (_md5.EndsWith("*") && !rom.MD5.StartsWith(_md5.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
// Filter on sha1
if (_sha1 != "")
{
if (_sha1.StartsWith("*") && _sha1.EndsWith("*") && !rom.SHA1.ToLowerInvariant().Contains(_sha1.ToLowerInvariant().Replace("*", "")))
{
continue;
}
else if (_sha1.StartsWith("*") && !rom.SHA1.EndsWith(_sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
else if (_sha1.EndsWith("*") && !rom.SHA1.StartsWith(_sha1.Replace("*", ""), StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
// If it made it this far, add the rom to the output dictionary
if (dict.ContainsKey(key))
{
dict[key].Add(rom);
}
else
{
List<RomData> temp = new List<RomData>();
temp.Add(rom);
dict.Add(key, temp);
}
}
// Now clean up by removing the old list
datdata.Roms[key] = null;
}
// Get the correct output values
datdata.FileName = Path.GetFileNameWithoutExtension(datdata.FileName) + " (Filtered)" + Path.GetExtension(datdata.FileName);
datdata.Name += " (Filtered)";
datdata.Description += " (Filtered)";
datdata.Roms = dict;
// Now write the file out if anything is there and return
if (datdata.Roms.Count > 0)
{
return Output.WriteDatfile(datdata, _outdir, _logger);
}
// Otherwise, we return true because we did all we could
return true;
}
}
}

153
DATabase/Partials/DATabase_Inits.cs
View File

@@ -106,10 +106,21 @@ namespace SabreTools
/// <param name="datprefix">Add the dat name as a directory prefix</param>
/// <param name="romba">Output files in romba format</param>
/// <param name="tsv">Output files in TSV format</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="outdir">Optional param for output directory</param>
/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
/// <param name="dedup">True to dedupe the roms in the DAT, false otherwise (default)</param>
private static void InitUpdate(string input,
/* Normal DAT header info */
string filename,
string name,
string description,
@@ -131,6 +142,8 @@ namespace SabreTools
bool outputRC,
bool outputSD,
bool outputXML,
/* Missfile-specific DAT info */
bool usegame,
string prefix,
string postfix,
@@ -140,6 +153,20 @@ namespace SabreTools
bool datprefix,
bool romba,
bool tsv,
/* Filtering info */
string gamename,
string romname,
string romtype,
long sgt,
long slt,
long seq,
string crc,
string md5,
string sha1,
bool? nodump,
/* Output DAT info */
string outdir,
bool clean,
bool dedup)
@@ -232,93 +259,34 @@ namespace SabreTools
if (outputCMP)
{
userInputDat.OutputFormat = OutputFormat.ClrMamePro;
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
if (outputMiss || romba)
{
userInputDat.OutputFormat = OutputFormat.MissFile;
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
if (outputRC)
{
userInputDat.OutputFormat = OutputFormat.RomCenter;
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
if (outputSD)
{
userInputDat.OutputFormat = OutputFormat.SabreDat;
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
if (outputXML)
{
userInputDat.OutputFormat = OutputFormat.Xml;
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
if (!outputCMP && !(outputMiss || romba) && !outputRC && !outputSD && !outputXML)
{
InitUpdate(input, userInputDat, outdir, clean);
RomManipulation.Update(input, userInputDat, outdir, clean, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, _logger);
}
}
/// <summary>
/// Wrap converting and updating DAT file from any format to any format
/// </summary>
/// <param name="inputFileName">Name of the input file or folder</param>
/// <param name="datdata">User specified inputs contained in a DatData object</param>
/// <param name="outputDirectory">Optional param for output directory</param>
/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
private static void InitUpdate(string inputFileName, DatData datdata, string outputDirectory, bool clean = false)
{
// Clean the input strings
outputDirectory = outputDirectory.Replace("\"", "");
if (outputDirectory != "")
{
outputDirectory = Path.GetFullPath(outputDirectory) + Path.DirectorySeparatorChar;
}
inputFileName = inputFileName.Replace("\"", "");
if (File.Exists(inputFileName))
{
_logger.User("Converting \"" + Path.GetFileName(inputFileName) + "\"");
datdata = RomManipulation.Parse(inputFileName, 0, 0, datdata, _logger, true, clean);
// If the extension matches, append ".new" to the filename
string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
if (outputDirectory == "" && Path.GetExtension(inputFileName) == extension)
{
datdata.FileName += ".new";
}
Output.WriteDatfile(datdata, (outputDirectory == "" ? Path.GetDirectoryName(inputFileName) : outputDirectory), _logger);
}
else if (Directory.Exists(inputFileName))
{
inputFileName = Path.GetFullPath(inputFileName) + Path.DirectorySeparatorChar;
foreach (string file in Directory.EnumerateFiles(inputFileName, "*", SearchOption.AllDirectories))
{
_logger.User("Converting \"" + Path.GetFullPath(file).Remove(0, inputFileName.Length) + "\"");
DatData innerDatdata = (DatData)datdata.Clone();
innerDatdata.Roms = null;
innerDatdata = RomManipulation.Parse(file, 0, 0, innerDatdata, _logger, true, clean);
// If the extension matches, append ".new" to the filename
string extension = (innerDatdata.OutputFormat == OutputFormat.Xml || innerDatdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
if (outputDirectory == "" && Path.GetExtension(file) == extension)
{
innerDatdata.FileName += ".new";
}
Output.WriteDatfile(innerDatdata, (outputDirectory == "" ? Path.GetDirectoryName(file) : outputDirectory + Path.GetDirectoryName(file).Remove(0, inputFileName.Length - 1)), _logger);
}
}
else
{
_logger.Error("I'm sorry but " + inputFileName + " doesn't exist!");
}
return;
}
/// <summary>
/// Wrap trimming and merging a single DAT
/// </summary>
@@ -497,61 +465,6 @@ namespace SabreTools
statlog.Close();
}
/// <summary>
/// Wrap filtering a DAT or set of DATs
/// </summary>
/// <param name="inputs">List of inputs to be procesed</param>
/// <param name="outdir">Output directory for new files (optional)</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 file and console output</param>
private static void InitFilter(List<string> inputs, string outdir, string gamename, string romname, string romtype, long sgt,
long slt, long seq, string crc, string md5, string sha1, bool? nodump, Logger logger)
{
// Create new Filter objects for each input
Filter filter;
bool success = true;
foreach (string input in inputs)
{
string newinput = Path.GetFullPath(input.Replace("\"", ""));
if (File.Exists(newinput))
{
filter = new Filter(newinput, outdir, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, logger);
success &= filter.Process();
}
if (Directory.Exists(newinput))
{
foreach (string file in Directory.EnumerateFiles(newinput, "*", SearchOption.AllDirectories))
{
string nestedoutdir = "";
if (outdir != "")
{
nestedoutdir = outdir + Path.GetDirectoryName(file).Remove(0, newinput.Length);
}
filter = new Filter(file, nestedoutdir, gamename, romname, romtype, sgt, slt, seq, crc, md5, sha1, nodump, logger);
success &= filter.Process();
}
}
}
// If we failed, show the help
if (!success)
{
Console.WriteLine();
Build.Help();
}
}
/// <summary>
/// Wrap adding a new source to the database
/// </summary>