Allow callers to set source and machine index

SabreTools.Metadata.DatFiles.Test/ItemDatabaseTests.cs

@@ -23,9 +23,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            disk.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(disk, machineIndex, sourceIndex, statsOnly: false);
+            disk.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(disk, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Disk? actualDisk = actual as Disk;
@@ -42,9 +46,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem disk = new Disk { Name = "item" };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            disk.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(disk, machineIndex, sourceIndex, statsOnly: false);
+            disk.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(disk, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Disk? actualDisk = actual as Disk;
@@ -61,9 +69,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             var file = new File { SHA1 = "deadbeef" };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            file.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(file, machineIndex, sourceIndex, statsOnly: false);
+            file.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(file, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Assert.True(actual is File);
@@ -79,9 +91,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem file = new File();
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            file.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(file, machineIndex, sourceIndex, statsOnly: false);
+            file.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(file, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Assert.True(actual is File);
@@ -101,9 +117,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            media.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(media, machineIndex, sourceIndex, statsOnly: false);
+            media.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(media, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Assert.True(actual is Media);
@@ -122,9 +142,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            media.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(media, machineIndex, sourceIndex, statsOnly: false);
+            media.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(media, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Assert.True(actual is Media);
@@ -145,9 +169,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(rom, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(rom, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Rom? actualRom = actual as Rom;
@@ -170,9 +198,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(rom, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(rom, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Rom? actualRom = actual as Rom;
@@ -195,9 +227,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(rom, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(rom, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Rom? actualRom = actual as Rom;
@@ -216,9 +252,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem rom = new Rom { Name = "item" };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(rom, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(rom, statsOnly: false);
 
             DatItem actual = Assert.Single(dict.GetItemsForBucket("default")).Value;
             Rom? actualRom = actual as Rom;
@@ -237,9 +277,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom { Name = "item" };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: true);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: true);
 
             Assert.Empty(dict.GetItemsForBucket("default"));
         }
@@ -253,9 +297,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom { Name = "item" };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             Assert.Single(dict.GetItemsForBucket("default"));
         }
@@ -322,9 +370,15 @@ namespace SabreTools.Metadata.DatFiles.Test
             // Setup the dictionary
             var dict = new ItemDatabase();
             long sourceIndex = dict.AddSource(source);
+            rom1.SourceIndex = sourceIndex;
+            rom2.SourceIndex = sourceIndex;
+
             long machineIndex = dict.AddMachine(machine);
-            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
-            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+            rom1.MachineIndex = machineIndex;
+            rom2.MachineIndex = machineIndex;
+
+            dict.AddItem(rom1, statsOnly: false);
+            dict.AddItem(rom2, statsOnly: false);
 
             dict.ClearMarked();
             string key = Assert.Single(dict.SortedKeys);
@@ -347,9 +401,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom();
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetItemsForBucket(null, filter: false);
 
@@ -366,9 +424,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom();
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetItemsForBucket("INVALID", filter: false);
 
@@ -385,9 +447,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom { RemoveFlag = true };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetItemsForBucket("machine", filter: true);
 
@@ -404,9 +470,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom { RemoveFlag = true };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetItemsForBucket("machine", filter: false);
 
@@ -423,9 +493,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom();
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetItemsForBucket("machine", filter: false);
 
@@ -460,9 +534,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom();
 
             var dict = new ItemDatabase();
-            long machineIndex = dict.AddMachine(machine);
+
             long sourceIndex = dict.AddSource(source);
-            long itemIndex = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.SourceIndex = sourceIndex;
+            long machineIndex = dict.AddMachine(machine);
+            item.MachineIndex = machineIndex;
+
+            long itemIndex = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetMachineForItem(itemIndex);
             Assert.Equal(0, actual.Key);
@@ -497,9 +575,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem item = new Rom();
 
             var dict = new ItemDatabase();
-            long machineIndex = dict.AddMachine(machine);
+
             long sourceIndex = dict.AddSource(source);
-            long itemIndex = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.SourceIndex = sourceIndex;
+            long machineIndex = dict.AddMachine(machine);
+            item.MachineIndex = machineIndex;
+
+            long itemIndex = dict.AddItem(item, statsOnly: false);
 
             var actual = dict.GetSourceForItem(itemIndex);
             Assert.Equal(0, actual.Key);
@@ -517,7 +599,7 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             Machine machine = new Machine { Name = "game-1" };
 
-            DatItem datItem = new Rom
+            DatItem item = new Rom
             {
                 Name = "rom-1",
                 Size = 1024,
@@ -526,9 +608,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            dict.AddItem(datItem, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            dict.AddItem(item, statsOnly: false);
 
             dict.RemoveBucket("game-1");
 
@@ -546,7 +632,7 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             Machine machine = new Machine { Name = "game-1" };
 
-            DatItem datItem = new Rom
+            DatItem item = new Rom
             {
                 Name = "rom-1",
                 Size = 1024,
@@ -555,9 +641,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            long itemIndex = dict.AddItem(datItem, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            long itemIndex = dict.AddItem(item, statsOnly: false);
 
             dict.RemoveItem(itemIndex);
 
@@ -632,13 +722,25 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             // Setup the dictionary
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom1.SourceIndex = sourceIndex;
+            rom2.SourceIndex = sourceIndex;
+            rom3.SourceIndex = sourceIndex;
+            rom4.SourceIndex = sourceIndex;
+
             long machine1Index = dict.AddMachine(machine1);
+            rom1.MachineIndex = machine1Index;
+            rom2.MachineIndex = machine1Index;
+
             long machine2Index = dict.AddMachine(machine2);
-            dict.AddItem(rom1, machine1Index, sourceIndex, statsOnly: false);
-            dict.AddItem(rom2, machine1Index, sourceIndex, statsOnly: false);
-            dict.AddItem(rom3, machine2Index, sourceIndex, statsOnly: false);
-            dict.AddItem(rom4, machine2Index, sourceIndex, statsOnly: false);
+            rom3.MachineIndex = machine2Index;
+            rom4.MachineIndex = machine2Index;
+
+            dict.AddItem(rom1, statsOnly: false);
+            dict.AddItem(rom2, statsOnly: false);
+            dict.AddItem(rom3, statsOnly: false);
+            dict.AddItem(rom4, statsOnly: false);
 
             dict.BucketBy(itemKey);
             Assert.Equal(expected, dict.SortedKeys.Length);
@@ -672,10 +774,17 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             // Setup the dictionary
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom1.SourceIndex = sourceIndex;
+            rom2.SourceIndex = sourceIndex;
+
             long machineIndex = dict.AddMachine(machine);
-            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
-            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+            rom1.MachineIndex = machineIndex;
+            rom2.MachineIndex = machineIndex;
+
+            dict.AddItem(rom1, statsOnly: false);
+            dict.AddItem(rom2, statsOnly: false);
 
             dict.Deduplicate();
             Assert.Equal(1, dict.DatStatistics.TotalCount);
@@ -732,18 +841,22 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             var romA = new Rom
             {
+                SourceIndex = sourceAIndex,
+                MachineIndex = machineAIndex,
                 Name = "same-name",
                 CRC32 = "BEEFDEAD"
             };
-            long romAIndex = dict.AddItem(romA, machineAIndex, sourceAIndex);
+            long romAIndex = dict.AddItemInternal(romA);
             KeyValuePair<long, DatItem>? romAPair = new KeyValuePair<long, DatItem>(romAIndex, romA);
 
             var romB = new Rom
             {
+                SourceIndex = sourceBIndex,
+                MachineIndex = machineBIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romBIndex = dict.AddItem(romB, machineBIndex, sourceBIndex);
+            long romBIndex = dict.AddItemInternal(romB);
             KeyValuePair<long, DatItem>? romBPair = new KeyValuePair<long, DatItem>(romBIndex, romB);
 
             var actual = dict.GetDuplicateStatus(romAPair, sourceA, romBPair, sourceB);
@@ -768,18 +881,22 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             var romA = new Rom
             {
+                SourceIndex = sourceAIndex,
+                MachineIndex = machineAIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romAIndex = dict.AddItem(romA, machineAIndex, sourceAIndex);
+            long romAIndex = dict.AddItemInternal(romA);
             KeyValuePair<long, DatItem>? romAPair = new KeyValuePair<long, DatItem>(romAIndex, romA);
 
             var romB = new Rom
             {
+                SourceIndex = sourceBIndex,
+                MachineIndex = machineBIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romBIndex = dict.AddItem(romB, machineBIndex, sourceBIndex);
+            long romBIndex = dict.AddItemInternal(romB);
             KeyValuePair<long, DatItem>? romBPair = new KeyValuePair<long, DatItem>(romBIndex, romB);
 
             var actual = dict.GetDuplicateStatus(romAPair, sourceA, romBPair, sourceB);
@@ -804,18 +921,22 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             var romA = new Rom
             {
+                SourceIndex = sourceAIndex,
+                MachineIndex = machineAIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romAIndex = dict.AddItem(romA, machineAIndex, sourceAIndex);
+            long romAIndex = dict.AddItemInternal(romA);
             KeyValuePair<long, DatItem>? romAPair = new KeyValuePair<long, DatItem>(romAIndex, romA);
 
             var romB = new Rom
             {
+                SourceIndex = sourceBIndex,
+                MachineIndex = machineBIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romBIndex = dict.AddItem(romB, machineBIndex, sourceBIndex);
+            long romBIndex = dict.AddItemInternal(romB);
             KeyValuePair<long, DatItem>? romBPair = new KeyValuePair<long, DatItem>(romBIndex, romB);
 
             var actual = dict.GetDuplicateStatus(romAPair, sourceA, romBPair, sourceB);
@@ -840,18 +961,22 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             var romA = new Rom
             {
+                SourceIndex = sourceAIndex,
+                MachineIndex = machineAIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romAIndex = dict.AddItem(romA, machineAIndex, sourceAIndex);
+            long romAIndex = dict.AddItemInternal(romA);
             KeyValuePair<long, DatItem>? romAPair = new KeyValuePair<long, DatItem>(romAIndex, romA);
 
             var romB = new Rom
             {
+                SourceIndex = sourceBIndex,
+                MachineIndex = machineBIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romBIndex = dict.AddItem(romB, machineBIndex, sourceBIndex);
+            long romBIndex = dict.AddItemInternal(romB);
             KeyValuePair<long, DatItem>? romBPair = new KeyValuePair<long, DatItem>(romBIndex, romB);
 
             var actual = dict.GetDuplicateStatus(romAPair, sourceA, romBPair, sourceB);
@@ -876,18 +1001,22 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             var romA = new Rom
             {
+                SourceIndex = sourceAIndex,
+                MachineIndex = machineAIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romAIndex = dict.AddItem(romA, machineAIndex, sourceAIndex);
+            long romAIndex = dict.AddItemInternal(romA);
             KeyValuePair<long, DatItem>? romAPair = new KeyValuePair<long, DatItem>(romAIndex, romA);
 
             var romB = new Rom
             {
+                SourceIndex = sourceBIndex,
+                MachineIndex = machineBIndex,
                 Name = "same-name",
                 CRC32 = "DEADBEEF"
             };
-            long romBIndex = dict.AddItem(romB, machineBIndex, sourceBIndex);
+            long romBIndex = dict.AddItemInternal(romB);
             KeyValuePair<long, DatItem>? romBPair = new KeyValuePair<long, DatItem>(romBIndex, romB);
 
             var actual = dict.GetDuplicateStatus(romAPair, sourceA, romBPair, sourceB);
@@ -924,10 +1053,17 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             // Setup the dictionary
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom1.SourceIndex = sourceIndex;
+            rom2.SourceIndex = sourceIndex;
+
             long machineIndex = dict.AddMachine(machine);
-            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
-            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+            rom1.MachineIndex = machineIndex;
+            rom2.MachineIndex = machineIndex;
+
+            dict.AddItem(rom1, statsOnly: false);
+            dict.AddItem(rom2, statsOnly: false);
 
             // Setup the test item
             DatItem rom = new Rom
@@ -971,10 +1107,17 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             // Setup the dictionary
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            rom1.SourceIndex = sourceIndex;
+            rom2.SourceIndex = sourceIndex;
+
             long machineIndex = dict.AddMachine(machine);
-            dict.AddItem(rom1, machineIndex, sourceIndex, statsOnly: false);
-            dict.AddItem(rom2, machineIndex, sourceIndex, statsOnly: false);
+            rom1.MachineIndex = machineIndex;
+            rom2.MachineIndex = machineIndex;
+
+            dict.AddItem(rom1, statsOnly: false);
+            dict.AddItem(rom2, statsOnly: false);
 
             // Setup the test item
             DatItem rom = new Rom
@@ -1007,9 +1150,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             var dict = new ItemDatabase();
+
             long sourceIndex = dict.AddSource(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = dict.AddMachine(machine);
-            _ = dict.AddItem(item, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = dict.AddItem(item, statsOnly: false);
 
             Assert.Equal(1, dict.DatStatistics.TotalCount);
             Assert.Equal(1, dict.DatStatistics.GetItemCount(Data.Models.Metadata.ItemType.Rom));