From 007510cc0f196de20a51da52cad8935de36f844b Mon Sep 17 00:00:00 2001 From: Matt Nadareski Date: Wed, 2 Sep 2020 17:09:19 -0700 Subject: [PATCH] Promote Device --- SabreTools.Library/DatFiles/ItemDictionary.cs | 12 + SabreTools.Library/DatFiles/Json.cs | 3 + SabreTools.Library/DatFiles/Listxml.cs | 108 +++---- SabreTools.Library/DatFiles/SabreDat.cs | 31 ++ SabreTools.Library/DatItems/Auxiliary.cs | 54 ---- SabreTools.Library/DatItems/DatItem.cs | 4 + SabreTools.Library/DatItems/Device.cs | 297 ++++++++++++++++++ SabreTools.Library/DatItems/Enums.cs | 33 +- SabreTools.Library/DatItems/Extension.cs | 12 +- SabreTools.Library/DatItems/Instance.cs | 24 +- SabreTools.Library/DatItems/Machine.cs | 7 - SabreTools.Library/Filtering/Filter.cs | 178 +++++------ SabreTools.Library/Tools/Converters.cs | 67 ++-- 13 files changed, 551 insertions(+), 279 deletions(-) create mode 100644 SabreTools.Library/DatItems/Device.cs diff --git a/SabreTools.Library/DatFiles/ItemDictionary.cs b/SabreTools.Library/DatFiles/ItemDictionary.cs index 5530773a..34ae5342 100644 --- a/SabreTools.Library/DatFiles/ItemDictionary.cs +++ b/SabreTools.Library/DatFiles/ItemDictionary.cs @@ -119,6 +119,12 @@ namespace SabreTools.Library.DatFiles [JsonIgnore] public long ConfigurationCount { get; private set; } = 0; + /// + /// Number of Device items + /// + [JsonIgnore] + public long DeviceCount { get; private set; } = 0; + /// /// Number of Device Reference items /// @@ -544,6 +550,9 @@ namespace SabreTools.Library.DatFiles case ItemType.Configuration: ConfigurationCount++; break; + case ItemType.Device: + DeviceCount++; + break; case ItemType.DeviceReference: DeviceReferenceCount++; break; @@ -709,6 +718,9 @@ namespace SabreTools.Library.DatFiles case ItemType.Configuration: ConfigurationCount--; break; + case ItemType.Device: + DeviceCount--; + break; case ItemType.DeviceReference: DeviceReferenceCount--; break; diff --git a/SabreTools.Library/DatFiles/Json.cs b/SabreTools.Library/DatFiles/Json.cs index 1b06e0ce..ac06d5fb 100644 --- a/SabreTools.Library/DatFiles/Json.cs +++ b/SabreTools.Library/DatFiles/Json.cs @@ -232,6 +232,9 @@ namespace SabreTools.Library.DatFiles case ItemType.Configuration: datItem = datItemObj.ToObject(); break; + case ItemType.Device: + datItem = datItemObj.ToObject(); + break; case ItemType.DeviceReference: datItem = datItemObj.ToObject(); break; diff --git a/SabreTools.Library/DatFiles/Listxml.cs b/SabreTools.Library/DatFiles/Listxml.cs index 734757ad..2dc9ab18 100644 --- a/SabreTools.Library/DatFiles/Listxml.cs +++ b/SabreTools.Library/DatFiles/Listxml.cs @@ -268,6 +268,31 @@ namespace SabreTools.Library.DatFiles reader.Skip(); break; + case "device": + var device = new Device + { + DeviceType = reader.GetAttribute("type"), + Tag = reader.GetAttribute("tag"), + FixedImage = reader.GetAttribute("fixed_image"), + Mandatory = reader.GetAttribute("mandatory"), + Interface = reader.GetAttribute("interface"), + + Source = new Source + { + Index = indexId, + Name = filename, + }, + }; + + // Now read the internal tags + ReadDevice(reader.ReadSubtree(), device); + + datItems.Add(device); + + // Skip the device now that we've processed it + reader.Skip(); + break; + case "device_ref": datItems.Add(new DeviceReference { @@ -538,27 +563,6 @@ namespace SabreTools.Library.DatFiles reader.Skip(); break; - case "device": - var device = new Device(); - device.Type = reader.GetAttribute("type"); - device.Tag = reader.GetAttribute("tag"); - device.FixedImage = reader.GetAttribute("fixed_image"); - device.Mandatory = reader.GetAttribute("mandatory"); - device.Interface = reader.GetAttribute("interface"); - - // Now read the internal tags - ReadDevice(reader.ReadSubtree(), device); - - // Ensure the list exists - if (machine.Devices == null) - machine.Devices = new List(); - - machine.Devices.Add(device); - - // Skip the device now that we've processed it - reader.Skip(); - break; - default: reader.Read(); break; @@ -1317,38 +1321,6 @@ namespace SabreTools.Library.DatFiles xtw.WriteEndElement(); } } - if (datItem.Machine.Devices != null) - { - foreach (var device in datItem.Machine.Devices) - { - xtw.WriteStartElement("device"); - xtw.WriteOptionalAttributeString("type", device.Type); - xtw.WriteOptionalAttributeString("tag", device.Tag); - xtw.WriteOptionalAttributeString("fixed_image", device.FixedImage); - xtw.WriteOptionalAttributeString("mandatory", device.Mandatory); - xtw.WriteOptionalAttributeString("interface", device.Interface); - if (device.Instances != null) - { - foreach (var instance in device.Instances) - { - xtw.WriteStartElement("instance"); - xtw.WriteOptionalAttributeString("name", instance.Name); - xtw.WriteOptionalAttributeString("briefname", instance.BriefName); - xtw.WriteEndElement(); - } - } - if (device.Extensions != null) - { - foreach (var extension in device.Extensions) - { - xtw.WriteStartElement("extension"); - xtw.WriteOptionalAttributeString("name", extension.Name); - xtw.WriteEndElement(); - } - } - xtw.WriteEndElement(); - } - } xtw.Flush(); } @@ -1493,6 +1465,36 @@ namespace SabreTools.Library.DatFiles xtw.WriteEndElement(); break; + case ItemType.Device: + var device = datItem as Device; + xtw.WriteStartElement("device"); + xtw.WriteOptionalAttributeString("type", device.DeviceType); + xtw.WriteOptionalAttributeString("tag", device.Tag); + xtw.WriteOptionalAttributeString("fixed_image", device.FixedImage); + xtw.WriteOptionalAttributeString("mandatory", device.Mandatory); + xtw.WriteOptionalAttributeString("interface", device.Interface); + if (device.Instances != null) + { + foreach (var instance in device.Instances) + { + xtw.WriteStartElement("instance"); + xtw.WriteOptionalAttributeString("name", instance.Name); + xtw.WriteOptionalAttributeString("briefname", instance.BriefName); + xtw.WriteEndElement(); + } + } + if (device.Extensions != null) + { + foreach (var extension in device.Extensions) + { + xtw.WriteStartElement("extension"); + xtw.WriteOptionalAttributeString("name", extension.Name); + xtw.WriteEndElement(); + } + } + xtw.WriteEndElement(); + break; + case ItemType.DeviceReference: var deviceRef = datItem as DeviceReference; xtw.WriteStartElement("device_ref"); diff --git a/SabreTools.Library/DatFiles/SabreDat.cs b/SabreTools.Library/DatFiles/SabreDat.cs index 75c9c9cc..cd064bd4 100644 --- a/SabreTools.Library/DatFiles/SabreDat.cs +++ b/SabreTools.Library/DatFiles/SabreDat.cs @@ -1322,6 +1322,37 @@ namespace SabreTools.Library.DatFiles xtw.WriteEndElement(); break; + case ItemType.Device: + var device = datItem as Device; + xtw.WriteStartElement("file"); + xtw.WriteAttributeString("type", "device"); + xtw.WriteOptionalAttributeString("type", device.DeviceType); + xtw.WriteOptionalAttributeString("tag", device.Tag); + xtw.WriteOptionalAttributeString("fixed_image", device.FixedImage); + xtw.WriteOptionalAttributeString("mandatory", device.Mandatory); + xtw.WriteOptionalAttributeString("interface", device.Interface); + if (device.Instances != null) + { + foreach (var instance in device.Instances) + { + xtw.WriteStartElement("instance"); + xtw.WriteOptionalAttributeString("name", instance.Name); + xtw.WriteOptionalAttributeString("briefname", instance.BriefName); + xtw.WriteEndElement(); + } + } + if (device.Extensions != null) + { + foreach (var extension in device.Extensions) + { + xtw.WriteStartElement("extension"); + xtw.WriteOptionalAttributeString("name", extension.Name); + xtw.WriteEndElement(); + } + } + xtw.WriteEndElement(); + break; + case ItemType.DeviceReference: var deviceRef = datItem as DeviceReference; xtw.WriteStartElement("file"); diff --git a/SabreTools.Library/DatItems/Auxiliary.cs b/SabreTools.Library/DatItems/Auxiliary.cs index 6cb19455..7f32395b 100644 --- a/SabreTools.Library/DatItems/Auxiliary.cs +++ b/SabreTools.Library/DatItems/Auxiliary.cs @@ -98,60 +98,6 @@ namespace SabreTools.Library.DatItems #endregion } - /// - /// Represents one ListXML device - /// - /// TODO: Promote to DatItem level (contains list) - [JsonObject("device")] - public class Device - { - #region Fields - - /// - /// Device type - /// - [JsonProperty("type", DefaultValueHandling = DefaultValueHandling.Ignore)] - public string Type { get; set; } - - /// - /// Device tag - /// - [JsonProperty("tag", DefaultValueHandling = DefaultValueHandling.Ignore)] - public string Tag { get; set; } - - /// - /// Fixed image format - /// - [JsonProperty("fixed_image", DefaultValueHandling = DefaultValueHandling.Ignore)] - public string FixedImage { get; set; } - - /// - /// Determines if the devices is mandatory - /// - [JsonProperty("mandatory", DefaultValueHandling = DefaultValueHandling.Ignore)] - public string Mandatory { get; set; } // TODO: bool? - - /// - /// Device interface - /// - [JsonProperty("interface", DefaultValueHandling = DefaultValueHandling.Ignore)] - public string Interface { get; set; } - - /// - /// Device instances - /// - [JsonProperty("instances", DefaultValueHandling = DefaultValueHandling.Ignore)] - public List Instances { get; set; } - - /// - /// Device extensions - /// - [JsonProperty("extensions", DefaultValueHandling = DefaultValueHandling.Ignore)] - public List Extensions { get; set; } - - #endregion - } - /// /// Represents one ListXML display /// diff --git a/SabreTools.Library/DatItems/DatItem.cs b/SabreTools.Library/DatItems/DatItem.cs index 5b32b6c2..abe911dd 100644 --- a/SabreTools.Library/DatItems/DatItem.cs +++ b/SabreTools.Library/DatItems/DatItem.cs @@ -479,6 +479,9 @@ namespace SabreTools.Library.DatItems case ItemType.Configuration: return new Configuration(); + case ItemType.Device: + return new Device(); + case ItemType.DeviceReference: return new DeviceReference(); @@ -538,6 +541,7 @@ namespace SabreTools.Library.DatItems ItemType.Chip => new Chip(), ItemType.Condition => new Condition(), ItemType.Configuration => new Configuration(), + ItemType.Device => new Device(), ItemType.DeviceReference => new DeviceReference(), ItemType.DipSwitch => new DipSwitch(), ItemType.Disk => new Disk(), diff --git a/SabreTools.Library/DatItems/Device.cs b/SabreTools.Library/DatItems/Device.cs new file mode 100644 index 00000000..90c7ce09 --- /dev/null +++ b/SabreTools.Library/DatItems/Device.cs @@ -0,0 +1,297 @@ +using System.Collections.Generic; +using System.Linq; + +using SabreTools.Library.Filtering; +using Newtonsoft.Json; + +/// +/// This holds all of the auxiliary types needed for proper parsing +/// +namespace SabreTools.Library.DatItems +{ + /// + /// Represents a single device on the machine + /// + [JsonObject("device")] + public class Device : DatItem + { + #region Fields + + /// + /// Device type + /// + [JsonProperty("type", DefaultValueHandling = DefaultValueHandling.Ignore)] + public string DeviceType { get; set; } + + /// + /// Device tag + /// + [JsonProperty("tag", DefaultValueHandling = DefaultValueHandling.Ignore)] + public string Tag { get; set; } + + /// + /// Fixed image format + /// + [JsonProperty("fixed_image", DefaultValueHandling = DefaultValueHandling.Ignore)] + public string FixedImage { get; set; } + + /// + /// Determines if the devices is mandatory + /// + [JsonProperty("mandatory", DefaultValueHandling = DefaultValueHandling.Ignore)] + public string Mandatory { get; set; } // TODO: bool? + + /// + /// Device interface + /// + [JsonProperty("interface", DefaultValueHandling = DefaultValueHandling.Ignore)] + public string Interface { get; set; } + + /// + /// Device instances + /// + [JsonProperty("instances", DefaultValueHandling = DefaultValueHandling.Ignore)] + public List Instances { get; set; } + + /// + /// Device extensions + /// + [JsonProperty("extensions", DefaultValueHandling = DefaultValueHandling.Ignore)] + public List Extensions { get; set; } + + #endregion + + #region Accessors + + /// + /// Set fields with given values + /// + /// Mappings dictionary + public override void SetFields(Dictionary mappings) + { + // Set base fields + base.SetFields(mappings); + + // Handle Device-specific fields + if (mappings.Keys.Contains(Field.DatItem_DeviceType)) + DeviceType = mappings[Field.DatItem_DeviceType]; + + if (mappings.Keys.Contains(Field.DatItem_Tag)) + Tag = mappings[Field.DatItem_Tag]; + + if (mappings.Keys.Contains(Field.DatItem_FixedImage)) + FixedImage = mappings[Field.DatItem_FixedImage]; + + if (mappings.Keys.Contains(Field.DatItem_Mandatory)) + Mandatory = mappings[Field.DatItem_Mandatory]; + + if (mappings.Keys.Contains(Field.DatItem_Interface)) + Interface = mappings[Field.DatItem_Interface]; + + // TODO: Handle DatItem_Instance* + // TODO: Handle DatItem_Extension* + } + + #endregion + + #region Constructors + + /// + /// Create a default, empty Device object + /// + public Device() + { + ItemType = ItemType.Device; + } + + #endregion + + #region Cloning Methods + + public override object Clone() + { + return new Device() + { + ItemType = this.ItemType, + DupeType = this.DupeType, + + AltName = this.AltName, + AltTitle = this.AltTitle, + + Original = this.Original, + OpenMSXSubType = this.OpenMSXSubType, + OpenMSXType = this.OpenMSXType, + Remark = this.Remark, + Boot = this.Boot, + + Part = this.Part, + Features = this.Features, + AreaName = this.AreaName, + AreaSize = this.AreaSize, + AreaWidth = this.AreaWidth, + AreaEndianness = this.AreaEndianness, + Value = this.Value, + LoadFlag = this.LoadFlag, + + Machine = this.Machine.Clone() as Machine, + Source = this.Source.Clone() as Source, + Remove = this.Remove, + + DeviceType = this.DeviceType, + Tag = this.Tag, + FixedImage = this.FixedImage, + Mandatory = this.Mandatory, + Interface = this.Interface, + Instances = this.Instances, + Extensions = this.Extensions, + }; + } + + #endregion + + #region Comparision Methods + + public override bool Equals(DatItem other) + { + // If we don't have a Device, return false + if (ItemType != other.ItemType) + return false; + + // Otherwise, treat it as a Device + Device newOther = other as Device; + + // If the Device information matches + return (DeviceType == newOther.DeviceType + && Tag == newOther.Tag + && FixedImage == newOther.FixedImage + && Mandatory == newOther.Mandatory + && Interface == newOther.Interface); + + // TODO: Handle DatItem_Instance* + // TODO: Handle DatItem_Extension* + } + + #endregion + + #region Filtering + + /// + /// Check to see if a DatItem passes the filter + /// + /// Filter to check against + /// True if the item passed the filter, false otherwise + public override bool PassesFilter(Filter filter) + { + // Check common fields first + if (!base.PassesFilter(filter)) + return false; + + // Filter on device type + if (filter.DatItem_DeviceType.MatchesPositiveSet(DeviceType) == false) + return false; + if (filter.DatItem_DeviceType.MatchesNegativeSet(DeviceType) == true) + return false; + + // Filter on tag + if (filter.DatItem_Tag.MatchesPositiveSet(Tag) == false) + return false; + if (filter.DatItem_Tag.MatchesNegativeSet(Tag) == true) + return false; + + // Filter on fixed image + if (filter.DatItem_FixedImage.MatchesPositiveSet(FixedImage) == false) + return false; + if (filter.DatItem_FixedImage.MatchesNegativeSet(FixedImage) == true) + return false; + + // Filter on mandatory + if (filter.DatItem_Mandatory.MatchesPositiveSet(Mandatory) == false) + return false; + if (filter.DatItem_Mandatory.MatchesNegativeSet(Mandatory) == true) + return false; + + // Filter on interface + if (filter.DatItem_Interface.MatchesPositiveSet(Interface) == false) + return false; + if (filter.DatItem_Interface.MatchesNegativeSet(Interface) == true) + return false; + + // TODO: Handle DatItem_Instance* + // TODO: Handle DatItem_Extension* + + return true; + } + + /// + /// Remove fields from the DatItem + /// + /// List of Fields to remove + public override void RemoveFields(List fields) + { + // Remove common fields first + base.RemoveFields(fields); + + // Remove the fields + if (fields.Contains(Field.DatItem_DeviceType)) + DeviceType = null; + + if (fields.Contains(Field.DatItem_Tag)) + Tag = null; + + if (fields.Contains(Field.DatItem_FixedImage)) + FixedImage = null; + + if (fields.Contains(Field.DatItem_Mandatory)) + Mandatory = null; + + if (fields.Contains(Field.DatItem_Interface)) + Interface = null; + + // TODO: Handle DatItem_Instance* + // TODO: Handle DatItem_Extension* + } + + #endregion + + #region Sorting and Merging + + /// + /// Replace fields from another item + /// + /// DatItem to pull new information from + /// List of Fields representing what should be updated + public override void ReplaceFields(DatItem item, List fields) + { + // Replace common fields first + base.ReplaceFields(item, fields); + + // If we don't have a Device to replace from, ignore specific fields + if (item.ItemType != ItemType.Device) + return; + + // Cast for easier access + Device newItem = item as Device; + + // Replace the fields + if (fields.Contains(Field.DatItem_DeviceType)) + DeviceType = newItem.DeviceType; + + if (fields.Contains(Field.DatItem_Tag)) + Tag = newItem.Tag; + + if (fields.Contains(Field.DatItem_FixedImage)) + FixedImage = newItem.FixedImage; + + if (fields.Contains(Field.DatItem_Mandatory)) + Mandatory = newItem.Mandatory; + + if (fields.Contains(Field.DatItem_Interface)) + Interface = newItem.Interface; + + // TODO: Handle DatItem_Instance* + // TODO: Handle DatItem_Extension* + } + + #endregion + } +} diff --git a/SabreTools.Library/DatItems/Enums.cs b/SabreTools.Library/DatItems/Enums.cs index 0b77fae0..0052a501 100644 --- a/SabreTools.Library/DatItems/Enums.cs +++ b/SabreTools.Library/DatItems/Enums.cs @@ -233,23 +233,6 @@ namespace SabreTools.Library.DatItems Machine_Port_Analogs, Machine_Port_Analog_Mask, - // Devices - Machine_Devices, - Machine_Device_Type, - Machine_Device_Tag, - Machine_Device_FixedImage, - Machine_Device_Mandatory, - Machine_Device_Interface, - - // Devices.Instances - Machine_Device_Instances, - Machine_Device_Instance_Name, - Machine_Device_Instance_BriefName, - - // Devices.Extensions - Machine_Device_Extensions, - Machine_Device_Extension_Name, - #endregion #region Logiqx @@ -413,6 +396,21 @@ namespace SabreTools.Library.DatItems DatItem_Setting_Value, DatItem_Setting_Default, + // Device + DatItem_DeviceType, + DatItem_FixedImage, + DatItem_Mandatory, + DatItem_Interface, + + // Device.Instances + DatItem_Instances, + DatItem_Instance_Name, + DatItem_Instance_BriefName, + + // Device.Extensions + DatItem_Extensions, + DatItem_Extension_Name, + // DipSwitch.Values DatItem_Values, DatItem_Value_Name, @@ -492,6 +490,7 @@ namespace SabreTools.Library.DatItems Chip, Condition, Configuration, + Device, DeviceReference, DipSwitch, Driver, diff --git a/SabreTools.Library/DatItems/Extension.cs b/SabreTools.Library/DatItems/Extension.cs index 499041d4..2e4e2d9c 100644 --- a/SabreTools.Library/DatItems/Extension.cs +++ b/SabreTools.Library/DatItems/Extension.cs @@ -45,8 +45,8 @@ namespace SabreTools.Library.DatItems base.SetFields(mappings); // Handle Sample-specific fields - if (mappings.Keys.Contains(Field.Machine_Device_Extension_Name)) - Name = mappings[Field.Machine_Device_Extension_Name]; + if (mappings.Keys.Contains(Field.DatItem_Extension_Name)) + Name = mappings[Field.DatItem_Extension_Name]; } #endregion @@ -158,9 +158,9 @@ namespace SabreTools.Library.DatItems return false; // Filter on item name - if (filter.Machine_Device_Extension_Name.MatchesPositiveSet(Name) == false) + if (filter.DatItem_Extension_Name.MatchesPositiveSet(Name) == false) return false; - if (filter.Machine_Device_Extension_Name.MatchesNegativeSet(Name) == true) + if (filter.DatItem_Extension_Name.MatchesNegativeSet(Name) == true) return false; return true; @@ -176,7 +176,7 @@ namespace SabreTools.Library.DatItems base.RemoveFields(fields); // Remove the fields - if (fields.Contains(Field.Machine_Device_Extension_Name)) + if (fields.Contains(Field.DatItem_Extension_Name)) Name = null; } @@ -212,7 +212,7 @@ namespace SabreTools.Library.DatItems Extension newItem = item as Extension; // Replace the fields - if (fields.Contains(Field.Machine_Device_Extension_Name)) + if (fields.Contains(Field.DatItem_Extension_Name)) Name = newItem.Name; } diff --git a/SabreTools.Library/DatItems/Instance.cs b/SabreTools.Library/DatItems/Instance.cs index 35bc8423..1880ffd1 100644 --- a/SabreTools.Library/DatItems/Instance.cs +++ b/SabreTools.Library/DatItems/Instance.cs @@ -51,11 +51,11 @@ namespace SabreTools.Library.DatItems base.SetFields(mappings); // Handle Instance-specific fields - if (mappings.Keys.Contains(Field.Machine_Device_Instance_Name)) - Name = mappings[Field.Machine_Device_Instance_Name]; + if (mappings.Keys.Contains(Field.DatItem_Instance_Name)) + Name = mappings[Field.DatItem_Instance_Name]; - if (mappings.Keys.Contains(Field.Machine_Device_Instance_BriefName)) - BriefName = mappings[Field.Machine_Device_Instance_BriefName]; + if (mappings.Keys.Contains(Field.DatItem_Instance_BriefName)) + BriefName = mappings[Field.DatItem_Instance_BriefName]; } #endregion @@ -169,15 +169,15 @@ namespace SabreTools.Library.DatItems return false; // Filter on item name - if (filter.Machine_Device_Instance_Name.MatchesPositiveSet(Name) == false) + if (filter.DatItem_Instance_Name.MatchesPositiveSet(Name) == false) return false; - if (filter.Machine_Device_Instance_Name.MatchesNegativeSet(Name) == true) + if (filter.DatItem_Instance_Name.MatchesNegativeSet(Name) == true) return false; // Filter on brief name - if (filter.Machine_Device_Instance_BriefName.MatchesPositiveSet(Name) == false) + if (filter.DatItem_Instance_BriefName.MatchesPositiveSet(Name) == false) return false; - if (filter.Machine_Device_Instance_BriefName.MatchesNegativeSet(Name) == true) + if (filter.DatItem_Instance_BriefName.MatchesNegativeSet(Name) == true) return false; return true; @@ -193,10 +193,10 @@ namespace SabreTools.Library.DatItems base.RemoveFields(fields); // Remove the fields - if (fields.Contains(Field.Machine_Device_Instance_Name)) + if (fields.Contains(Field.DatItem_Instance_Name)) Name = null; - if (fields.Contains(Field.Machine_Device_Instance_BriefName)) + if (fields.Contains(Field.DatItem_Instance_BriefName)) BriefName = null; } @@ -232,10 +232,10 @@ namespace SabreTools.Library.DatItems Instance newItem = item as Instance; // Replace the fields - if (fields.Contains(Field.Machine_Device_Instance_Name)) + if (fields.Contains(Field.DatItem_Instance_Name)) Name = newItem.Name; - if (fields.Contains(Field.Machine_Device_Instance_BriefName)) + if (fields.Contains(Field.DatItem_Instance_BriefName)) BriefName = newItem.BriefName; } diff --git a/SabreTools.Library/DatItems/Machine.cs b/SabreTools.Library/DatItems/Machine.cs index b57f260b..64b90065 100644 --- a/SabreTools.Library/DatItems/Machine.cs +++ b/SabreTools.Library/DatItems/Machine.cs @@ -170,12 +170,6 @@ namespace SabreTools.Library.DatItems [JsonProperty("ports", DefaultValueHandling = DefaultValueHandling.Ignore)] public List Ports { get; set; } = null; - /// - /// List of associated devices - /// - [JsonProperty("devices", DefaultValueHandling = DefaultValueHandling.Ignore)] - public List Devices { get; set; } = null; - #endregion #region Logiqx Fields @@ -531,7 +525,6 @@ namespace SabreTools.Library.DatItems Displays = this.Displays, Inputs = this.Inputs, Ports = this.Ports, - Devices = this.Devices, #endregion diff --git a/SabreTools.Library/Filtering/Filter.cs b/SabreTools.Library/Filtering/Filter.cs index 72803432..f9ca680c 100644 --- a/SabreTools.Library/Filtering/Filter.cs +++ b/SabreTools.Library/Filtering/Filter.cs @@ -98,23 +98,6 @@ namespace SabreTools.Library.Filtering public FilterItem Machine_Port_Analogs { get; private set; } = new FilterItem() { Neutral = null }; public FilterItem Machine_Port_Analog_Mask { get; private set; } = new FilterItem(); - // Devices - public FilterItem Machine_Devices { get; private set; } = new FilterItem() { Neutral = null }; - public FilterItem Machine_Device_Type { get; private set; } = new FilterItem(); - public FilterItem Machine_Device_Tag { get; private set; } = new FilterItem(); - public FilterItem Machine_Device_FixedImage { get; private set; } = new FilterItem(); - public FilterItem Machine_Device_Mandatory { get; private set; } = new FilterItem(); - public FilterItem Machine_Device_Interface { get; private set; } = new FilterItem(); - - // Devices.Instances - public FilterItem Machine_Device_Instances { get; private set; } = new FilterItem() { Neutral = null }; - public FilterItem Machine_Device_Instance_Name { get; private set; } = new FilterItem(); - public FilterItem Machine_Device_Instance_BriefName { get; private set; } = new FilterItem(); - - // Devices.Extensions - public FilterItem Machine_Device_Extensions { get; private set; } = new FilterItem() { Neutral = null }; - public FilterItem Machine_Device_Extension_Name { get; private set; } = new FilterItem(); - #endregion #region Logiqx @@ -278,6 +261,21 @@ namespace SabreTools.Library.Filtering public FilterItem DatItem_Setting_Value { get; private set; } = new FilterItem(); public FilterItem DatItem_Setting_Default { get; private set; } = new FilterItem() { Neutral = null }; + // Device + public FilterItem DatItem_DeviceType { get; private set; } = new FilterItem(); + public FilterItem DatItem_FixedImage { get; private set; } = new FilterItem(); + public FilterItem DatItem_Mandatory { get; private set; } = new FilterItem(); + public FilterItem DatItem_Interface { get; private set; } = new FilterItem(); + + // Device.Instances + public FilterItem DatItem_Instances { get; private set; } = new FilterItem() { Neutral = null }; + public FilterItem DatItem_Instance_Name { get; private set; } = new FilterItem(); + public FilterItem DatItem_Instance_BriefName { get; private set; } = new FilterItem(); + + // Device.Extensions + public FilterItem DatItem_Extensions { get; private set; } = new FilterItem() { Neutral = null }; + public FilterItem DatItem_Extension_Name { get; private set; } = new FilterItem(); + // DipSwitch.Values public FilterItem DatItem_Values { get; private set; } = new FilterItem() { Neutral = null }; public FilterItem DatItem_Value_Name { get; private set; } = new FilterItem(); @@ -805,86 +803,6 @@ namespace SabreTools.Library.Filtering Machine_Port_Analog_Mask.PositiveSet.Add(value); break; - // Devices - case Field.Machine_Devices: - if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) - Machine_Devices.Neutral = false; - else - Machine_Devices.Neutral = true; - break; - - case Field.Machine_Device_Type: - if (negate) - Machine_Device_Type.NegativeSet.Add(value); - else - Machine_Device_Type.PositiveSet.Add(value); - break; - - case Field.Machine_Device_Tag: - if (negate) - Machine_Device_Tag.NegativeSet.Add(value); - else - Machine_Device_Tag.PositiveSet.Add(value); - break; - - case Field.Machine_Device_FixedImage: - if (negate) - Machine_Device_FixedImage.NegativeSet.Add(value); - else - Machine_Device_FixedImage.PositiveSet.Add(value); - break; - - case Field.Machine_Device_Mandatory: - if (negate) - Machine_Device_Mandatory.NegativeSet.Add(value); - else - Machine_Device_Mandatory.PositiveSet.Add(value); - break; - - case Field.Machine_Device_Interface: - if (negate) - Machine_Device_Interface.NegativeSet.Add(value); - else - Machine_Device_Interface.PositiveSet.Add(value); - break; - - // Devices.Instances - case Field.Machine_Device_Instances: - if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) - Machine_Device_Instances.Neutral = false; - else - Machine_Device_Instances.Neutral = true; - break; - - case Field.Machine_Device_Instance_Name: - if (negate) - Machine_Device_Instance_Name.NegativeSet.Add(value); - else - Machine_Device_Instance_Name.PositiveSet.Add(value); - break; - - case Field.Machine_Device_Instance_BriefName: - if (negate) - Machine_Device_Instance_BriefName.NegativeSet.Add(value); - else - Machine_Device_Instance_BriefName.PositiveSet.Add(value); - break; - - // Devices.Extensions - case Field.Machine_Device_Extensions: - if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) - Machine_Device_Extensions.Neutral = false; - else - Machine_Device_Extensions.Neutral = true; - break; - - case Field.Machine_Device_Extension_Name: - if (negate) - Machine_Device_Extension_Name.NegativeSet.Add(value); - else - Machine_Device_Extension_Name.PositiveSet.Add(value); - break; - #endregion #region Logiqx @@ -1606,6 +1524,72 @@ namespace SabreTools.Library.Filtering DatItem_Setting_Default.Neutral = true; break; + // Device + case Field.DatItem_DeviceType: + if (negate) + DatItem_DeviceType.NegativeSet.Add(value); + else + DatItem_DeviceType.PositiveSet.Add(value); + break; + + case Field.DatItem_FixedImage: + if (negate) + DatItem_FixedImage.NegativeSet.Add(value); + else + DatItem_FixedImage.PositiveSet.Add(value); + break; + + case Field.DatItem_Mandatory: + if (negate) + DatItem_Mandatory.NegativeSet.Add(value); + else + DatItem_Mandatory.PositiveSet.Add(value); + break; + + case Field.DatItem_Interface: + if (negate) + DatItem_Interface.NegativeSet.Add(value); + else + DatItem_Interface.PositiveSet.Add(value); + break; + + // Devices.Instances + case Field.DatItem_Instances: + if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) + DatItem_Instances.Neutral = false; + else + DatItem_Instances.Neutral = true; + break; + + case Field.DatItem_Instance_Name: + if (negate) + DatItem_Instance_Name.NegativeSet.Add(value); + else + DatItem_Instance_Name.PositiveSet.Add(value); + break; + + case Field.DatItem_Instance_BriefName: + if (negate) + DatItem_Instance_BriefName.NegativeSet.Add(value); + else + DatItem_Instance_BriefName.PositiveSet.Add(value); + break; + + // Devices.Extensions + case Field.DatItem_Extensions: + if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) + DatItem_Extensions.Neutral = false; + else + DatItem_Extensions.Neutral = true; + break; + + case Field.DatItem_Extension_Name: + if (negate) + DatItem_Extension_Name.NegativeSet.Add(value); + else + DatItem_Extension_Name.PositiveSet.Add(value); + break; + // DipSwitches.Values case Field.DatItem_Values: if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase)) diff --git a/SabreTools.Library/Tools/Converters.cs b/SabreTools.Library/Tools/Converters.cs index e2fed492..1accfea3 100644 --- a/SabreTools.Library/Tools/Converters.cs +++ b/SabreTools.Library/Tools/Converters.cs @@ -683,39 +683,6 @@ namespace SabreTools.Library.Tools case "port_analog_mask": return Field.Machine_Port_Analog_Mask; - case "devices": - return Field.Machine_Devices; - - case "device_type": - return Field.Machine_Device_Type; - - case "device_tag": - return Field.Machine_Device_Tag; - - case "device_fixedimage": - return Field.Machine_Device_FixedImage; - - case "device_mandatory": - return Field.Machine_Device_Mandatory; - - case "device_interface": - return Field.Machine_Device_Interface; - - case "device_instances": - return Field.Machine_Device_Instances; - - case "device_instance_name": - return Field.Machine_Device_Instance_Name; - - case "device_instance_briefname": - return Field.Machine_Device_Instance_BriefName; - - case "device_extensions": - return Field.Machine_Device_Extensions; - - case "device_extension_name": - return Field.Machine_Device_Extension_Name; - #endregion #region Logiqx @@ -1097,6 +1064,34 @@ namespace SabreTools.Library.Tools case "value_default": return Field.DatItem_Value_Default; + // Device + case "devicetype": + return Field.DatItem_DeviceType; + + case "fixedimage": + return Field.DatItem_FixedImage; + + case "mandatory": + return Field.DatItem_Mandatory; + + case "interface": + return Field.DatItem_Interface; + + case "instances": + return Field.DatItem_Instances; + + case "instance_name": + return Field.DatItem_Instance_Name; + + case "instance_briefname": + return Field.DatItem_Instance_BriefName; + + case "extensions": + return Field.DatItem_Extensions; + + case "extension_name": + return Field.DatItem_Extension_Name; + // Driver case "supportstatus": return Field.DatItem_SupportStatus; @@ -1672,6 +1667,8 @@ namespace SabreTools.Library.Tools return ItemType.Condition; case "configuration": return ItemType.Configuration; + case "device": + return ItemType.Device; case "device_ref": return ItemType.DeviceReference; case "dipswitch": @@ -1716,6 +1713,7 @@ namespace SabreTools.Library.Tools "chip" => ItemType.Chip, "condition" => ItemType.Condition, "configuration" => ItemType.Configuration, + "device" => ItemType.Device, "device_ref" => ItemType.DeviceReference, "dipswitch" => ItemType.DipSwitch, "disk" => ItemType.Disk, @@ -2289,6 +2287,8 @@ namespace SabreTools.Library.Tools return "condition"; case ItemType.Configuration: return "configuration"; + case ItemType.Device: + return "device"; case ItemType.DeviceReference: return "device_ref"; case ItemType.DipSwitch: @@ -2333,6 +2333,7 @@ namespace SabreTools.Library.Tools ItemType.Chip => "chip", ItemType.Condition => "condition", ItemType.Configuration => "configuration", + ItemType.Device => "device", ItemType.DeviceReference => "device_ref", ItemType.DipSwitch => "dipswitch", ItemType.Disk => "disk",