/// <inheritdoc/>
public override (bool, string) ValidateArguments()
{
if (Arguments.Count != 2)
{
string message = $"Invoked {Name} and expected 2 arguments, but {Arguments.Count} arguments were provided";
return(false, message);
}
// Read in the individual arguments
MachineField extraMachineField = Arguments[0].AsMachineField();
DatItemField extraDatItemField = Arguments[0].AsDatItemField();
string extraFile = Arguments[1];
// If we had an invalid input, log and continue
if (extraMachineField == MachineField.NULL &&
extraDatItemField == DatItemField.NULL)
{
string message = $"{Arguments[0]} was an invalid field name";
return(false, message);
}
if (!File.Exists(extraFile))
{
string message = $"{Arguments[1]} was an invalid file name";
return(false, message);
}
return(true, null);
}
/// <summary>
/// Set remover from a value
/// </summary>
/// <param name="field">Key for the remover to be set</param>
public bool SetRemover(string field)
{
// If the key is null or empty, return false
if (string.IsNullOrWhiteSpace(field))
{
return(false);
}
// If we have a Machine field
MachineField machineField = field.AsMachineField();
if (machineField != MachineField.NULL)
{
MachineFields.Add(machineField);
return(true);
}
// If we have a DatItem field
DatItemField datItemField = field.AsDatItemField();
if (datItemField != DatItemField.NULL)
{
DatItemFields.Add(datItemField);
return(true);
}
return(false);
}
/// <summary>
/// Set multiple filters from key
/// </summary>
/// <param name="key">Key for the filter to be set</param>
/// <param name="values">List of values for the filter</param>
/// <param name="negate">True if negative filter, false otherwise</param>
public void SetFilter(MachineField key, List <string> values, bool negate)
{
foreach (string value in values)
{
SetFilter(key, value, negate);
}
}
/// <summary>
/// Populate the filters objects using a set of key:value filters
/// </summary>
/// <param name="filters">List of key:value where ~key/!key is negated</param>
public void PopulateFiltersFromList(List <string> filters)
{
// Instantiate the filters, if necessary
MachineFilter ??= new MachineFilter();
DatItemFilter ??= new DatItemFilter();
// If the list is null or empty, just return
if (filters == null || filters.Count == 0)
{
return;
}
InternalStopwatch watch = new InternalStopwatch("Populating filters from list");
foreach (string filterPair in filters)
{
(string field, string value, bool negate) = ProcessFilterPair(filterPair);
// If we don't even have a possible filter pair
if (field == null && value == null)
{
continue;
}
// Machine fields
MachineField machineField = field.AsMachineField();
if (machineField != MachineField.NULL)
{
MachineFilter.SetFilter(machineField, value, negate);
MachineFilter.HasFilters = true;
continue;
}
// DatItem fields
DatItemField datItemField = field.AsDatItemField();
if (datItemField != DatItemField.NULL)
{
DatItemFilter.SetFilter(datItemField, value, negate);
DatItemFilter.HasFilters = true;
continue;
}
// If we didn't match anything, log an error
logger.Warning($"The value {field} did not match any filterable field names. Please check the wiki for more details on supported field names.");
}
watch.Stop();
}
/// <inheritdoc/>
public override (bool, string) ValidateArguments()
{
if (Arguments.Count < 2 || Arguments.Count > 4)
{
string message = $"Invoked {Name} and expected between 2-4 arguments, but {Arguments.Count} arguments were provided";
return(false, message);
}
// Read in the individual arguments
DatHeaderField filterDatHeaderField = Arguments[0].AsDatHeaderField();
MachineField filterMachineField = Arguments[0].AsMachineField();
DatItemField filterDatItemField = Arguments[0].AsDatItemField();
bool? filterRemove = false;
if (Arguments.Count >= 3)
{
filterRemove = Arguments[2].AsYesNo();
}
bool?filterPerMachine = false;
if (Arguments.Count >= 4)
{
filterPerMachine = Arguments[3].AsYesNo();
}
// If we had an invalid input, log and continue
if (filterDatHeaderField == DatHeaderField.NULL &&
filterMachineField == MachineField.NULL &&
filterDatItemField == DatItemField.NULL)
{
string message = $"{Arguments[0]} was an invalid field name";
return(false, message);
}
if (filterRemove == null)
{
string message = $"{Arguments[2]} was an invalid true/false value";
return(false, message);
}
if (filterPerMachine == null)
{
string message = $"{Arguments[3]} was an invalid true/false value";
return(false, message);
}
return(true, null);
}
/// <inheritdoc/>
public override void Process(BatchState batchState)
{
// Read in the individual arguments
MachineField filterMachineField = Arguments[0].AsMachineField();
DatItemField filterDatItemField = Arguments[0].AsDatItemField();
string filterValue = Arguments[1];
bool? filterRemove = false;
if (Arguments.Count >= 3)
{
filterRemove = Arguments[2].AsYesNo();
}
bool?filterPerMachine = false;
if (Arguments.Count >= 4)
{
filterPerMachine = Arguments[3].AsYesNo();
}
// Create filter to run filters from
Filter filter = new Filter
{
MachineFilter = new MachineFilter {
HasFilters = true
},
DatItemFilter = new DatItemFilter {
HasFilters = true
},
};
// Set the possible filters
filter.MachineFilter.SetFilter(filterMachineField, filterValue, filterRemove.Value);
filter.DatItemFilter.SetFilter(filterDatItemField, filterValue, filterRemove.Value);
// Apply the filters blindly
filter.ApplyFilters(batchState.DatFile, filterPerMachine.Value);
// Cleanup after the filter
// TODO: We might not want to remove immediately
batchState.DatFile.Items.ClearMarked();
batchState.DatFile.Items.ClearEmpty();
}
/// <inheritdoc/>
public override void Process(BatchState batchState)
{
// Read in the individual arguments
MachineField extraMachineField = Arguments[0].AsMachineField();
DatItemField extraDatItemField = Arguments[0].AsDatItemField();
string extraFile = Arguments[1];
// Create the extra INI
ExtraIni extraIni = new ExtraIni();
ExtraIniItem extraIniItem = new ExtraIniItem
{
MachineField = extraMachineField,
DatItemField = extraDatItemField,
};
extraIniItem.PopulateFromFile(extraFile);
extraIni.Items.Add(extraIniItem);
// Apply the extra INI blindly
extraIni.ApplyExtras(batchState.DatFile);
}
public void AsMachineFieldTest(string field, MachineField expected)
{
MachineField actual = field.AsMachineField();
Assert.Equal(expected, actual);
}
/// <summary>
/// Set a single filter from key
/// </summary>
/// <param name="key">Key for the filter to be set</param>
/// <param name="value">Value of the filter</param>
/// <param name="negate">True if negative filter, false otherwise</param>
public void SetFilter(MachineField key, string value, bool negate)
{
switch (key)
{
#region Common
case MachineField.Name:
SetStringFilter(Name, value, negate);
break;
case MachineField.Comment:
SetStringFilter(Comment, value, negate);
break;
case MachineField.Description:
SetStringFilter(Description, value, negate);
break;
case MachineField.Year:
SetStringFilter(Year, value, negate);
break;
case MachineField.Manufacturer:
SetStringFilter(Manufacturer, value, negate);
break;
case MachineField.Publisher:
SetStringFilter(Publisher, value, negate);
break;
case MachineField.Category:
SetStringFilter(Category, value, negate);
break;
case MachineField.RomOf:
SetStringFilter(RomOf, value, negate);
break;
case MachineField.CloneOf:
SetStringFilter(CloneOf, value, negate);
break;
case MachineField.SampleOf:
SetStringFilter(SampleOf, value, negate);
break;
case MachineField.Type:
if (negate)
{
Type.Negative |= value.AsMachineType();
}
else
{
Type.Positive |= value.AsMachineType();
}
break;
#endregion
#region AttractMode
case MachineField.Players:
SetStringFilter(Players, value, negate);
break;
case MachineField.Rotation:
SetStringFilter(Rotation, value, negate);
break;
case MachineField.Control:
SetStringFilter(Control, value, negate);
break;
case MachineField.Status:
SetStringFilter(Status, value, negate);
break;
case MachineField.DisplayCount:
SetStringFilter(DisplayCount, value, negate);
break;
case MachineField.DisplayType:
SetStringFilter(DisplayType, value, negate);
break;
case MachineField.Buttons:
SetStringFilter(Buttons, value, negate);
break;
#endregion
#region ListXML
case MachineField.History:
SetStringFilter(History, value, negate);
break;
case MachineField.SourceFile:
SetStringFilter(SourceFile, value, negate);
break;
case MachineField.Runnable:
if (negate)
{
Runnable.Negative |= value.AsRunnable();
}
else
{
Runnable.Positive |= value.AsRunnable();
}
break;
#endregion
#region Logiqx
case MachineField.Board:
SetStringFilter(Board, value, negate);
break;
case MachineField.RebuildTo:
SetStringFilter(RebuildTo, value, negate);
break;
#endregion
#region Logiqx EmuArc
case MachineField.TitleID:
SetStringFilter(TitleID, value, negate);
break;
case MachineField.Developer:
SetStringFilter(Developer, value, negate);
break;
case MachineField.Genre:
SetStringFilter(Genre, value, negate);
break;
case MachineField.Subgenre:
SetStringFilter(Subgenre, value, negate);
break;
case MachineField.Ratings:
SetStringFilter(Ratings, value, negate);
break;
case MachineField.Score:
SetStringFilter(Score, value, negate);
break;
case MachineField.Enabled:
SetStringFilter(Enabled, value, negate);
break;
case MachineField.CRC:
SetBooleanFilter(CRC, value, negate);
break;
case MachineField.RelatedTo:
SetStringFilter(RelatedTo, value, negate);
break;
#endregion
#region OpenMSX
case MachineField.GenMSXID:
SetStringFilter(GenMSXID, value, negate);
break;
case MachineField.System:
SetStringFilter(System, value, negate);
break;
case MachineField.Country:
SetStringFilter(Country, value, negate);
break;
#endregion
#region SoftwareList
case MachineField.Supported:
if (negate)
{
Supported.Negative |= value.AsSupported();
}
else
{
Supported.Positive |= value.AsSupported();
}
break;
#endregion
}
}