mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
672 lines
16 KiB
C#
672 lines
16 KiB
C#
using System.Collections.Generic;
|
|
|
|
using SabreTools.Library.Data;
|
|
using SabreTools.Library.Help;
|
|
|
|
namespace RombaSharp
|
|
{
|
|
public partial class RombaSharp
|
|
{
|
|
#region Private Flag features
|
|
|
|
private static Feature copyFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"copy",
|
|
"-copy",
|
|
"Copy files to output instead of rebuilding",
|
|
FeatureType.Flag);
|
|
}
|
|
} // Unique to RombaSharp
|
|
private static Feature fixdatOnlyFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"fixdatOnly",
|
|
"-fixdatOnly",
|
|
"only fix dats and don't generate torrentzips",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
private static Feature logOnlyFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"log-only",
|
|
"-log-only",
|
|
"Only write out actions to log",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
private static Feature noDbFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"no-db",
|
|
"-no-db",
|
|
"archive into depot but do not touch DB index and ignore only-needed flag",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
private static Feature onlyNeededFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"only-needed",
|
|
"-only-needed",
|
|
"only archive ROM files actually referenced by DAT files from the DAT index",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
private static Feature skipInitialScanFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"skip-initial-scan",
|
|
"-skip-initial-scan",
|
|
"skip the initial scan of the files to determine amount of work",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
private static Feature useGolangZipFlag
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"use-golang-zip",
|
|
"-use-golang-zip",
|
|
"use go zip implementation instead of zlib",
|
|
FeatureType.Flag);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Int32 features
|
|
|
|
private static Feature include7ZipsInt32Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"include-7zips",
|
|
"-include-7zips",
|
|
"flag value == 0 means: add 7zip files themselves into the depot in addition to their contents, flag value == 2 means add 7zip files themselves but don't add content",
|
|
FeatureType.Int32);
|
|
}
|
|
}
|
|
private static Feature includeGZipsInt32Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"include-gzips",
|
|
"-include-gzips",
|
|
"flag value == 0 means: add gzip files themselves into the depot in addition to their contents, flag value == 2 means add gzip files themselves but don't add content",
|
|
FeatureType.Int32);
|
|
}
|
|
}
|
|
private static Feature includeZipsInt32Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"include-zips",
|
|
"-include-zips",
|
|
"flag value == 0 means: add zip files themselves into the depot in addition to their contents, flag value == 2 means add zip files themselves but don't add content",
|
|
FeatureType.Int32);
|
|
}
|
|
}
|
|
private static Feature subworkersInt32Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"subworkers",
|
|
"-subworkers",
|
|
"how many subworkers to launch for each worker",
|
|
FeatureType.Int32);
|
|
}
|
|
} // Defaults to Workers count in config
|
|
private static Feature workersInt32Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"workers",
|
|
"-workers",
|
|
"how many workers to launch for the job",
|
|
FeatureType.Int32);
|
|
}
|
|
} // Defaults to Workers count in config
|
|
|
|
#endregion
|
|
|
|
#region Private Int64 features
|
|
|
|
private static Feature sizeInt64Input
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"size",
|
|
"-size",
|
|
"size of the rom to lookup",
|
|
FeatureType.Int64);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private List<String> features
|
|
|
|
private static Feature datsListStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"dats",
|
|
"-dats",
|
|
"purge only roms declared in these dats",
|
|
FeatureType.List);
|
|
}
|
|
}
|
|
private static Feature depotListStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"depot",
|
|
"-depot",
|
|
"work only on specified depot path",
|
|
FeatureType.List);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private String features
|
|
|
|
private static Feature backupStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"backup",
|
|
"-backup",
|
|
"backup directory where backup files are moved to",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature descriptionStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"description",
|
|
"-description",
|
|
"description value in DAT header",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature missingSha1sStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"missingSha1s",
|
|
"-missingSha1s",
|
|
"write paths of dats with missing sha1s into this file",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature nameStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"name",
|
|
"-name",
|
|
"name value in DAT header",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature newStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"new",
|
|
"-new",
|
|
"new DAT file",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature oldStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"old",
|
|
"-old",
|
|
"old DAT file",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature outStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"out",
|
|
"-out",
|
|
"output file",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature resumeStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"resume",
|
|
"-resume",
|
|
"resume a previously interrupted operation from the specified path",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
private static Feature sourceStringInput
|
|
{
|
|
get
|
|
{
|
|
return new Feature(
|
|
"source",
|
|
"-source",
|
|
"source directory",
|
|
FeatureType.String);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static Help RetrieveHelp()
|
|
{
|
|
// Create and add the header to the Help object
|
|
string barrier = "-----------------------------------------";
|
|
List<string> helpHeader = new List<string>()
|
|
{
|
|
"RombaSharp - C# port of the Romba rom management tool",
|
|
barrier,
|
|
"Usage: RombaSharp [option] [filename|dirname] ...",
|
|
""
|
|
};
|
|
Help help = new Help(helpHeader);
|
|
|
|
#region Help
|
|
|
|
Feature helpFeature = new Feature(
|
|
"Help",
|
|
new List<string>() { "-?", "-h", "--help" },
|
|
"Show this help",
|
|
FeatureType.Flag);
|
|
|
|
#endregion
|
|
|
|
#region Script
|
|
|
|
Feature script = new Feature(
|
|
"Script",
|
|
"--script",
|
|
"Enable script mode (no clear screen)",
|
|
FeatureType.Flag,
|
|
longDescription: "For times when RombaSharp is being used in a scripted environment, the user may not want the screen to be cleared every time that it is called. This flag allows the user to skip clearing the screen on run just like if the console was being redirected.");
|
|
|
|
#endregion
|
|
|
|
#region Archive
|
|
|
|
Feature archive = new Feature(
|
|
"Archive",
|
|
"archive",
|
|
"Adds ROM files from the specified directories to the ROM archive.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Adds ROM files from the specified directories to the ROM archive.
|
|
Traverses the specified directory trees looking for zip files and normal files.
|
|
Unpacked files will be stored as individual entries. Prior to unpacking a zip
|
|
file, the external SHA1 is checked against the DAT index.
|
|
If -only-needed is set, only those files are put in the ROM archive that
|
|
have a current entry in the DAT index.");
|
|
archive.AddFeature(onlyNeededFlag);
|
|
archive.AddFeature(resumeStringInput);
|
|
archive.AddFeature(includeZipsInt32Input); // Defaults to 0
|
|
archive.AddFeature(workersInt32Input);
|
|
archive.AddFeature(includeGZipsInt32Input); // Defaults to 0
|
|
archive.AddFeature(include7ZipsInt32Input); // Defaults to 0
|
|
archive.AddFeature(skipInitialScanFlag);
|
|
archive.AddFeature(useGolangZipFlag);
|
|
archive.AddFeature(noDbFlag);
|
|
|
|
#endregion
|
|
|
|
#region Build
|
|
|
|
Feature build = new Feature(
|
|
"Build",
|
|
"build",
|
|
"For each specified DAT file it creates the torrentzip files.",
|
|
FeatureType.Flag,
|
|
longDescription: @"For each specified DAT file it creates the torrentzip files in the specified
|
|
output dir. The files will be placed in the specified location using a folder
|
|
structure according to the original DAT master directory tree structure.");
|
|
build.AddFeature(outStringInput);
|
|
build.AddFeature(fixdatOnlyFlag);
|
|
build.AddFeature(copyFlag);
|
|
build.AddFeature(workersInt32Input);
|
|
build.AddFeature(subworkersInt32Input);
|
|
|
|
#endregion
|
|
|
|
#region Cancel
|
|
|
|
Feature cancel = new Feature(
|
|
"Cancel",
|
|
"cancel",
|
|
"Cancels current long-running job",
|
|
FeatureType.Flag,
|
|
longDescription: @"Cancels current long-running job.");
|
|
|
|
#endregion
|
|
|
|
#region DatStats
|
|
|
|
Feature datstats = new Feature(
|
|
"DatStats",
|
|
"datstats",
|
|
"Prints dat stats.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Print dat stats.");
|
|
|
|
#endregion
|
|
|
|
#region DbStats
|
|
|
|
Feature dbstats = new Feature(
|
|
"DbStats",
|
|
"dbstats",
|
|
"Prints db stats.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Print db stats.");
|
|
|
|
#endregion
|
|
|
|
#region Diffdat
|
|
|
|
Feature diffdat = new Feature(
|
|
"Diffdat",
|
|
"diffdat",
|
|
"Creates a DAT file with those entries that are in -new DAT.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Creates a DAT file with those entries that are in -new DAT file and not
|
|
in -old DAT file. Ignores those entries in -old that are not in -new.");
|
|
diffdat.AddFeature(outStringInput);
|
|
diffdat.AddFeature(oldStringInput);
|
|
diffdat.AddFeature(newStringInput);
|
|
diffdat.AddFeature(nameStringInput);
|
|
diffdat.AddFeature(descriptionStringInput);
|
|
|
|
#endregion
|
|
|
|
#region Dir2Dat
|
|
|
|
Feature dir2dat = new Feature(
|
|
"Dir2Dat",
|
|
"dir2dat",
|
|
"Creates a DAT file for the specified input directory and saves it to the -out filename.",
|
|
FeatureType.Flag);
|
|
dir2dat.AddFeature(outStringInput);
|
|
dir2dat.AddFeature(sourceStringInput);
|
|
dir2dat.AddFeature(nameStringInput); // Defaults to "untitled"
|
|
dir2dat.AddFeature(descriptionStringInput);
|
|
|
|
#endregion
|
|
|
|
#region EDiffdat
|
|
|
|
Feature ediffdat = new Feature(
|
|
"EDiffdat",
|
|
"ediffdat",
|
|
"Creates a DAT file with those entries that are in -new DAT.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Creates a DAT file with those entries that are in -new DAT files and not
|
|
in -old DAT files. Ignores those entries in -old that are not in -new.");
|
|
ediffdat.AddFeature(outStringInput);
|
|
ediffdat.AddFeature(oldStringInput);
|
|
ediffdat.AddFeature(newStringInput);
|
|
|
|
#endregion
|
|
|
|
#region Export
|
|
|
|
// Unique to RombaSharp
|
|
Feature export = new Feature(
|
|
"Export",
|
|
"export",
|
|
"Exports db to export.csv",
|
|
FeatureType.Flag,
|
|
longDescription: "Exports db to standardized export.csv");
|
|
|
|
#endregion
|
|
|
|
#region Fixdat
|
|
|
|
Feature fixdat = new Feature(
|
|
"Fixdat",
|
|
"fixdat",
|
|
"For each specified DAT file it creates a fix DAT.",
|
|
FeatureType.Flag,
|
|
longDescription: @"For each specified DAT file it creates a fix DAT with the missing entries for
|
|
that DAT. If nothing is missing it doesn't create a fix DAT for that
|
|
particular DAT.");
|
|
fixdat.AddFeature(outStringInput);
|
|
fixdat.AddFeature(fixdatOnlyFlag); // Enabled by default
|
|
fixdat.AddFeature(workersInt32Input);
|
|
fixdat.AddFeature(subworkersInt32Input);
|
|
|
|
#endregion
|
|
|
|
#region Import
|
|
|
|
// Unique to RombaSharp
|
|
Feature import = new Feature(
|
|
"Import",
|
|
"import",
|
|
"Import a database from a formatted CSV file",
|
|
FeatureType.Flag,
|
|
longDescription: @"Import a database from a formatted CSV file");
|
|
|
|
#endregion
|
|
|
|
#region Lookup
|
|
|
|
Feature lookup = new Feature(
|
|
"Lookup",
|
|
"lookup",
|
|
"For each specified hash it looks up any available information.",
|
|
FeatureType.Flag,
|
|
longDescription: @"For each specified hash it looks up any available information (dat or rom).");
|
|
lookup.AddFeature(sizeInt64Input); // Defaults to -1
|
|
lookup.AddFeature(outStringInput);
|
|
|
|
#endregion
|
|
|
|
#region Memstats
|
|
|
|
Feature memstats = new Feature(
|
|
"Memstats",
|
|
"memstats",
|
|
"Prints memory stats.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Print memory stats.");
|
|
|
|
#endregion
|
|
|
|
#region Merge
|
|
|
|
Feature merge = new Feature(
|
|
"Merge",
|
|
"merge",
|
|
"Merges depot",
|
|
FeatureType.Flag,
|
|
longDescription: @"Merges specified depot into current depot.");
|
|
merge.AddFeature(onlyNeededFlag);
|
|
merge.AddFeature(resumeStringInput);
|
|
merge.AddFeature(workersInt32Input);
|
|
merge.AddFeature(skipInitialScanFlag);
|
|
|
|
#endregion
|
|
|
|
#region Miss
|
|
|
|
// Unique to RombaSharp
|
|
Feature miss = new Feature(
|
|
"Miss",
|
|
"miss",
|
|
"Create miss and have file",
|
|
FeatureType.Flag,
|
|
longDescription: @"For each specified DAT file, create miss and have file");
|
|
|
|
#endregion
|
|
|
|
#region Progress
|
|
|
|
Feature progress = new Feature(
|
|
"Progress",
|
|
"progress",
|
|
"Shows progress of the currently running command.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Shows progress of the currently running command.");
|
|
|
|
#endregion
|
|
|
|
#region Purge Backup
|
|
|
|
Feature purgeBackup = new Feature(
|
|
"Purge Backup",
|
|
"purge-backup",
|
|
"Moves DAT index entries for orphaned DATs.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Deletes DAT index entries for orphaned DATs and moves ROM files that are no
|
|
longer associated with any current DATs to the specified backup folder.
|
|
The files will be placed in the backup location using
|
|
a folder structure according to the original DAT master directory tree
|
|
structure. It also deletes the specified DATs from the DAT index.");
|
|
purgeBackup.AddFeature(backupStringInput);
|
|
purgeBackup.AddFeature(workersInt32Input);
|
|
purgeBackup.AddFeature(depotListStringInput);
|
|
purgeBackup.AddFeature(datsListStringInput);
|
|
purgeBackup.AddFeature(logOnlyFlag);
|
|
|
|
#endregion
|
|
|
|
#region Purge Delete
|
|
|
|
// Unique to RombaSharp
|
|
Feature purgeDelete = new Feature(
|
|
"Purge Delete",
|
|
"purge-delete",
|
|
"Deletes DAT index entries for orphaned DATs",
|
|
FeatureType.Flag);
|
|
purgeDelete.AddFeature(workersInt32Input);
|
|
purgeDelete.AddFeature(depotListStringInput);
|
|
purgeDelete.AddFeature(datsListStringInput);
|
|
purgeDelete.AddFeature(logOnlyFlag);
|
|
|
|
#endregion
|
|
|
|
#region Refresh DATs
|
|
|
|
Feature refreshDats = new Feature(
|
|
"Refresh DATs",
|
|
"refresh-dats",
|
|
"Refreshes the DAT index from the files in the DAT master directory tree.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Refreshes the DAT index from the files in the DAT master directory tree.
|
|
Detects any changes in the DAT master directory tree and updates the DAT index
|
|
accordingly, marking deleted or overwritten dats as orphaned and updating
|
|
contents of any changed dats.");
|
|
refreshDats.AddFeature(workersInt32Input);
|
|
refreshDats.AddFeature(missingSha1sStringInput);
|
|
|
|
#endregion
|
|
|
|
#region Recan Depots
|
|
|
|
// Unique to RombaSharp
|
|
Feature rescanDepots = new Feature(
|
|
"Rescan Depots",
|
|
"depot-rescan",
|
|
"Rescan a specific depot to get new information",
|
|
FeatureType.Flag);
|
|
|
|
#endregion
|
|
|
|
#region Shutdown
|
|
|
|
Feature shutdown = new Feature(
|
|
"Shutdown",
|
|
"shutdown",
|
|
"Gracefully shuts down server.",
|
|
FeatureType.Flag,
|
|
longDescription: @"Gracefully shuts down server saving all the cached data.");
|
|
|
|
#endregion
|
|
|
|
#region Version
|
|
|
|
Feature version = new Feature(
|
|
"Version",
|
|
"version",
|
|
"Prints version",
|
|
FeatureType.Flag,
|
|
longDescription: @"Prints version.");
|
|
|
|
#endregion
|
|
|
|
// Now, add all of the main features to the Help object
|
|
help.Add(helpFeature);
|
|
help.Add(script);
|
|
help.Add(archive);
|
|
help.Add(build);
|
|
help.Add(cancel);
|
|
help.Add(datstats);
|
|
help.Add(dbstats);
|
|
help.Add(diffdat);
|
|
help.Add(dir2dat);
|
|
help.Add(ediffdat);
|
|
help.Add(export);
|
|
help.Add(fixdat);
|
|
help.Add(import);
|
|
help.Add(lookup);
|
|
help.Add(memstats);
|
|
help.Add(merge);
|
|
help.Add(miss);
|
|
help.Add(purgeBackup);
|
|
help.Add(purgeDelete);
|
|
help.Add(refreshDats);
|
|
help.Add(rescanDepots);
|
|
help.Add(progress);
|
|
help.Add(shutdown);
|
|
help.Add(version);
|
|
|
|
return help;
|
|
}
|
|
}
|
|
}
|