Compare commits

...

109 Commits
1.1.3 ... 1.5.2

Author SHA1 Message Date
Matt Nadareski
ee8dad0c87 Bump version 2024-04-17 13:00:07 -04:00
Matt Nadareski
4163b2f22a Create non-typed variants of IWrapper and WrapperBase 2024-04-17 12:28:08 -04:00
Matt Nadareski
6aaf3afa38 Fix namespace issues 2024-04-17 11:52:22 -04:00
Matt Nadareski
2a7eb44281 Bump version 2024-04-17 11:45:26 -04:00
Matt Nadareski
08bbc93793 Update SabreTools.IO 2024-04-17 11:44:58 -04:00
Matt Nadareski
789478df13 Update SabreTools.IO 2024-04-16 13:16:59 -04:00
Matt Nadareski
cd4f1c9d97 Merge pull request #7 from SabreTools/deserializer-base
Deserializer base
2024-04-04 14:17:57 -04:00
Matt Nadareski
1a2e9fb942 Add PlayJ playlist wrapper 2024-04-04 14:15:27 -04:00
Matt Nadareski
d0865739de Add PIC wrapper 2024-04-04 14:13:03 -04:00
Matt Nadareski
0696bbab72 Add MoPaQ wrapper 2024-04-04 14:06:59 -04:00
Matt Nadareski
4b4c17ac24 Make model type inherent to interface 2024-04-04 14:03:02 -04:00
Matt Nadareski
d768172da1 Update README 2024-04-04 12:03:19 -04:00
Matt Nadareski
2a4d24309d Create base class for serializers 2024-04-04 12:03:19 -04:00
Matt Nadareski
bc01ce4552 Enforce IStreamDeserializer in base class 2024-04-04 12:03:19 -04:00
Matt Nadareski
ef0efe66bd Migrate IFileDeserializer implementation to base class 2024-04-04 12:03:19 -04:00
Matt Nadareski
7c21f65723 Migrate IByteSerializer implementation to base class 2024-04-04 12:03:19 -04:00
Matt Nadareski
cec53e907f Move static deserializers to base class 2024-04-04 12:03:19 -04:00
Matt Nadareski
006ced0430 Bump version 2024-04-04 12:00:53 -04:00
Matt Nadareski
bee6c0ba11 Add byte deserializers for remaining stream deserializers 2024-04-03 23:25:54 -04:00
Matt Nadareski
3cb880ff3f Update SabreTools.Models 2024-04-03 22:54:30 -04:00
Matt Nadareski
f1d54e4a14 Add XML byte deserialization 2024-04-03 22:41:49 -04:00
Matt Nadareski
f4aaed7f9c Move overlay extension method 2024-04-03 22:31:24 -04:00
Matt Nadareski
46ad76c5d2 Add flag for long/short SeparatedValue writing 2024-04-03 22:26:23 -04:00
Matt Nadareski
8f731cebc8 Add array constants for AttractMode 2024-04-03 22:21:39 -04:00
Matt Nadareski
6dbf9dacd6 Add flag for long/short AttractMode writing 2024-04-03 22:18:05 -04:00
Matt Nadareski
94ab760c67 Remove unnecessary code 2024-04-03 21:57:14 -04:00
Matt Nadareski
4ed3880bad Use SabreTools.Hashing for hash types 2024-04-03 21:56:21 -04:00
Matt Nadareski
ff8dcd30a5 Move some constants to the deserializer 2024-04-03 21:46:35 -04:00
Matt Nadareski
8ced91d0fa Move some constants to the deserializer 2024-04-03 21:44:02 -04:00
Matt Nadareski
f2c6fa2b8e Convert string serialization to new framework 2024-04-03 21:42:08 -04:00
Matt Nadareski
9b1bacd167 Move serializers to new organization 2024-04-03 21:27:50 -04:00
Matt Nadareski
964c97200c Move stream deserializers to new organization 2024-04-03 20:55:02 -04:00
Matt Nadareski
a3f3384ac9 Move file deserializers to new organization 2024-04-03 17:27:08 -04:00
Matt Nadareski
8b546fbf27 Start splitting serialziation differently for clarity 2024-04-03 16:41:54 -04:00
Matt Nadareski
15da711087 Rename IByteSerializer to IByteDeserializer 2024-04-03 16:37:26 -04:00
Matt Nadareski
bfee7dd449 Use better naming 2024-04-03 16:35:54 -04:00
Matt Nadareski
9de2a91e80 Fix inheritdoc 2024-04-03 16:15:48 -04:00
Matt Nadareski
bf50c801b2 Simplify some static deserializers 2024-04-03 16:00:18 -04:00
Matt Nadareski
c19a4a94f4 Use new static stream serializer 2024-04-03 15:50:06 -04:00
Matt Nadareski
b6fe94116b Add static serializers for IStreamSerializer 2024-04-03 15:43:36 -04:00
Matt Nadareski
bcf604c773 Use new static stream deserializer 2024-04-03 15:23:49 -04:00
Matt Nadareski
74984a9114 Add static deserializers for IStreamSerializer 2024-04-03 15:22:35 -04:00
Matt Nadareski
8c1e241286 Add static serializers for IFileSerializer 2024-04-03 14:58:06 -04:00
Matt Nadareski
f666d737cb Add static deserializers for IFileSerializer 2024-04-03 14:28:47 -04:00
Matt Nadareski
a01609f1d1 Add static serializers for IByteSerializer 2024-04-03 14:06:23 -04:00
Matt Nadareski
8ca9ccaf00 Handle invalid texture counts 2024-04-02 16:55:43 -04:00
Matt Nadareski
fc5374108c Bump version 2024-04-02 16:15:29 -04:00
Matt Nadareski
15452ded52 Use new IO extension 2024-04-02 16:12:08 -04:00
Matt Nadareski
49c6c4412b Update SabreTools.IO 2024-04-02 16:10:58 -04:00
Matt Nadareski
cfc53f66a8 Fix cuesheet serialization 2024-04-02 15:30:43 -04:00
Matt Nadareski
ec1fb7247c Add file serializers for all stream variants 2024-04-02 14:28:30 -04:00
Matt Nadareski
54b1eef8ae Better handle version 3 CFB files, probably (fixes #3) 2024-04-02 12:54:54 -04:00
Matt Nadareski
f448314309 Add file serializer for CFB 2024-04-02 12:45:31 -04:00
Matt Nadareski
c4e8debb15 Detect invalid dialog item counts (fixes #5) 2024-04-02 12:35:14 -04:00
Matt Nadareski
822839c813 Add file serializers for executable types 2024-04-02 12:06:56 -04:00
Matt Nadareski
27d36a11ca Add skeleton test executable 2024-04-02 11:56:27 -04:00
Matt Nadareski
92d9ca932d Move library code to subfolder 2024-04-02 11:51:39 -04:00
Deterous
69e1f5ff0b De/Serialize XboxOne/XSX catalog.js files (#6)
* Add JSON/catalog.js logic

* Proper json deserialize

* Update packages

* Catalog is UTF-16 LE, make BaseJsonFile encoding independent

* Bump version, use ST.Models 1.4.1

* Implement JsonFile as interface with UTF8 as default

* typo
2024-04-02 08:46:12 -07:00
Matt Nadareski
d265c14841 Bump version 2024-03-25 14:25:28 -04:00
Matt Nadareski
1148245226 Surface NE/LE/PE methods for other library use 2024-03-24 21:09:12 -04:00
Matt Nadareski
f53d9f94e6 Break if StringFileInfo child is total size 0 2024-03-22 23:46:05 -04:00
Matt Nadareski
4e3d832834 Ensure Listrom serializes to the correct model type 2024-03-19 15:47:13 -04:00
Matt Nadareski
0713dfafb2 Bump version 2024-03-12 16:35:45 -04:00
Matt Nadareski
c0d4f403c3 Update IO package 2024-03-12 16:34:32 -04:00
Matt Nadareski
5ed79166cf Update Models library 2024-03-12 16:29:05 -04:00
Matt Nadareski
17030cfb9f Fix Listxml type key issues 2024-03-12 12:58:27 -04:00
Matt Nadareski
530fa69d3c Fix OpenMSX cross-model serialization keys 2024-03-12 00:46:46 -04:00
Matt Nadareski
7a5956f599 Fix capitalization in RomCenter INI stream serializer 2024-03-11 23:08:10 -04:00
Matt Nadareski
5562768509 Fix separated value cross-model serialization 2024-03-11 22:47:38 -04:00
Matt Nadareski
aa538df229 All doctype overloads to take nullable objects 2024-03-11 22:31:40 -04:00
Matt Nadareski
b7b22cba32 Fix AttractMode writing 2024-03-11 14:52:32 -04:00
Matt Nadareski
fc489125d9 Fix serialization problem for listrom 2024-03-10 00:39:23 -05:00
Matt Nadareski
036589473d Fix serialziation problem for archive.org 2024-03-10 00:36:31 -05:00
Matt Nadareski
432ce85f89 Bump version 2024-03-05 11:16:22 -05:00
Matt Nadareski
438e8067eb Update SabreTools.IO 2024-03-05 11:12:59 -05:00
Matt Nadareski
9715507aaf Add nuget package and PR workflows 2024-02-27 19:17:20 -05:00
Matt Nadareski
b745d4b9f6 Update copyright year 2024-01-30 13:39:23 -05:00
Matt Nadareski
4271bd86b3 Bump version 2024-01-26 09:57:09 -05:00
Matt Nadareski
88de4be27b Fix too-long string values 2024-01-26 01:23:33 -05:00
Matt Nadareski
33905165f7 Bump version 2024-01-05 21:57:50 -05:00
Deterous
83ec3b6950 Update CueSheet.Deserializer.cs (#2)
* Update CueSheet.Deserializer.cs

Don't return null when cuesheet is not ended

* Explicitly deal with new track/file cases
2024-01-02 17:51:27 -08:00
Matt Nadareski
9b5d51884c Use more lenient file reading 2023-12-13 15:45:40 -05:00
Matt Nadareski
aaa6422921 Bump version 2023-11-21 21:11:24 -05:00
Matt Nadareski
f24b88031b Address some suggestions 2023-11-21 21:10:43 -05:00
Matt Nadareski
edf9fed751 Support .NET Framework 2.0 2023-11-21 20:59:20 -05:00
Matt Nadareski
beca747943 Fix other data endpoint issues 2023-11-15 12:44:32 -05:00
Matt Nadareski
58e538eff6 Bump version 2023-11-15 12:41:21 -05:00
Matt Nadareski
4f04c8aa89 Fix end-of-data issue, add .NET 8 syntax 2023-11-15 12:34:57 -05:00
Matt Nadareski
d7c1e4e83a Support ancient .NET 2023-11-14 14:50:47 -05:00
Matt Nadareski
975eefdc61 Expand supported RIDs 2023-11-08 22:51:40 -05:00
Matt Nadareski
d8cd5854ce Enable latest language version 2023-11-07 23:30:26 -05:00
Matt Nadareski
0790fc93b6 Bump version 2023-10-25 15:34:38 -04:00
Matt Nadareski
7f6c128521 Update README 2023-10-25 15:04:22 -04:00
Matt Nadareski
87df6b3ebd Add IRD wrapper 2023-10-25 14:51:07 -04:00
Matt Nadareski
2ca7326074 Implement IRD serializers 2023-10-25 14:43:43 -04:00
Matt Nadareski
3b90af7b3a Split XgdInfo into two proper wrappers 2023-10-25 13:29:59 -04:00
Matt Nadareski
6eda2f2541 Update models, add XgdInfo extensions 2023-10-25 13:17:36 -04:00
Matt Nadareski
defe1c53aa Port a version of XgdInfo from MPF 2023-10-24 23:33:53 -04:00
Matt Nadareski
e5fe0a71ef Add Xbox string serialization 2023-10-24 23:24:17 -04:00
Matt Nadareski
83450f693f Make Strings namespace and move Xbox 2023-10-24 23:20:27 -04:00
Matt Nadareski
1f70e1f544 Remove unnecessary validation / methods from Xbox 2023-10-24 23:05:16 -04:00
Matt Nadareski
4bfc83d5d4 Make XMID consistent with XeMID 2023-10-24 21:50:26 -04:00
Matt Nadareski
7364661900 Add two X360 publishers 2023-10-24 21:43:21 -04:00
Matt Nadareski
1cafc4079d Make XeMID logic a bit clearer 2023-10-24 16:56:41 -04:00
Matt Nadareski
0d62cbd1e9 Add XGD4 PIC reading 2023-09-28 23:25:25 -04:00
Matt Nadareski
bf753262a5 Update Models version 2023-09-22 16:05:20 -04:00
Matt Nadareski
5510b5d19d Fix inconsistent access issue 2023-09-16 00:55:31 -04:00
Matt Nadareski
d0f0ade757 Bump version 2023-09-16 00:44:35 -04:00
Matt Nadareski
26b03d8256 Make some base functionality public 2023-09-16 00:15:44 -04:00
282 changed files with 4096 additions and 6848 deletions

43
.github/workflows/build_nupkg.yml vendored Normal file
View File

@@ -0,0 +1,43 @@
name: Nuget Pack
on:
push:
branches: [ "main" ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
submodules: recursive
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
dotnet-version: 8.0.x
- name: Restore dependencies
run: dotnet restore
- name: Pack
run: dotnet pack
- name: Upload build
uses: actions/upload-artifact@v4
with:
name: 'Nuget Package'
path: 'SabreTools.Serialization/bin/Release/*.nupkg'
- name: Upload to rolling
uses: ncipollo/release-action@v1.14.0
with:
allowUpdates: True
artifacts: 'SabreTools.Serialization/bin/Release/*.nupkg'
body: 'Last built commit: ${{ github.sha }}'
name: 'Rolling Release'
prerelease: True
replacesArtifacts: True
tag: "rolling"
updateOnlyUnreleased: True

17
.github/workflows/check_pr.yml vendored Normal file
View File

@@ -0,0 +1,17 @@
name: Build PR
on: [pull_request]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
dotnet-version: 8.0.x
- name: Build
run: dotnet build

View File

@@ -1,14 +0,0 @@
namespace SabreTools.Serialization
{
/// <summary>
/// Separated value serializer/deserializer for AttractMode romlists
/// </summary>
public static class AttractMode
{
public const string HeaderWithoutRomname = "#Name;Title;Emulator;CloneOf;Year;Manufacturer;Category;Players;Rotation;Control;Status;DisplayCount;DisplayType;AltRomname;AltTitle;Extra;Buttons";
public const int HeaderWithoutRomnameCount = 17;
public const string HeaderWithRomname = "#Romname;Title;Emulator;Cloneof;Year;Manufacturer;Category;Players;Rotation;Control;Status;DisplayCount;DisplayType;AltRomname;AltTitle;Extra;Buttons;Favourite;Tags;PlayedCount;PlayedTime;FileIsAvailable";
public const int HeaderWithRomnameCount = 22;
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.AACS;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class AACS : IByteSerializer<MediaKeyBlock>
{
/// <inheritdoc/>
#if NET48
public MediaKeyBlock Deserialize(byte[] data, int offset)
#else
public MediaKeyBlock? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.AACS().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.BDPlus;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class BDPlus : IByteSerializer<SVM>
{
/// <inheritdoc/>
#if NET48
public SVM Deserialize(byte[] data, int offset)
#else
public SVM? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.BDPlus().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.BFPK;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class BFPK : IByteSerializer<Archive>
{
/// <inheritdoc/>
#if NET48
public Archive Deserialize(byte[] data, int offset)
#else
public Archive? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.BFPK().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class BSP : IByteSerializer<Models.BSP.File>
{
/// <inheritdoc/>
#if NET48
public Models.BSP.File Deserialize(byte[] data, int offset)
#else
public Models.BSP.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.BSP().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.CFB;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class CFB : IByteSerializer<Binary>
{
/// <inheritdoc/>
#if NET48
public Binary Deserialize(byte[] data, int offset)
#else
public Binary? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.CFB().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class CIA : IByteSerializer<Models.N3DS.CIA>
{
/// <inheritdoc/>
#if NET48
public Models.N3DS.CIA Deserialize(byte[] data, int offset)
#else
public Models.N3DS.CIA? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.CIA().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class GCF : IByteSerializer<Models.GCF.File>
{
/// <inheritdoc/>
#if NET48
public Models.GCF.File Deserialize(byte[] data, int offset)
#else
public Models.GCF.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.GCF().Deserialize(dataStream);
}
}
}

View File

@@ -1,30 +0,0 @@
using System.IO;
using SabreTools.Models.InstallShieldCabinet;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
// TODO: Add multi-cabinet reading
public partial class InstallShieldCabinet : IByteSerializer<Cabinet>
{
/// <inheritdoc/>
#if NET48
public Cabinet Deserialize(byte[] data, int offset)
#else
public Cabinet? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.InstallShieldCabinet().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.LinearExecutable;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class LinearExecutable : IByteSerializer<Executable>
{
/// <inheritdoc/>
#if NET48
public Executable Deserialize(byte[] data, int offset)
#else
public Executable? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.LinearExecutable().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.MSDOS;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class MSDOS : IByteSerializer<Executable>
{
/// <inheritdoc/>
#if NET48
public Executable Deserialize(byte[] data, int offset)
#else
public Executable? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.MSDOS().Deserialize(dataStream);
}
}
}

View File

@@ -1,30 +0,0 @@
using System.IO;
using SabreTools.Models.MicrosoftCabinet;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
// TODO: Add multi-cabinet reading
public partial class MicrosoftCabinet : IByteSerializer<Cabinet>
{
/// <inheritdoc/>
#if NET48
public Cabinet Deserialize(byte[] data, int offset)
#else
public Cabinet? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.MicrosoftCabinet().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.MoPaQ;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class MoPaQ : IByteSerializer<Archive>
{
/// <inheritdoc/>
#if NET48
public Archive Deserialize(byte[] data, int offset)
#else
public Archive? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.MoPaQ().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.N3DS;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class N3DS : IByteSerializer<Cart>
{
/// <inheritdoc/>
#if NET48
public Cart Deserialize(byte[] data, int offset)
#else
public Cart? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.N3DS().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class NCF : IByteSerializer<Models.NCF.File>
{
/// <inheritdoc/>
#if NET48
public Models.NCF.File Deserialize(byte[] data, int offset)
#else
public Models.NCF.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.NCF().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.NewExecutable;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class NewExecutable : IByteSerializer<Executable>
{
/// <inheritdoc/>
#if NET48
public Executable Deserialize(byte[] data, int offset)
#else
public Executable? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.NewExecutable().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.Nitro;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class Nitro : IByteSerializer<Cart>
{
/// <inheritdoc/>
#if NET48
public Cart Deserialize(byte[] data, int offset)
#else
public Cart? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.Nitro().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class PAK : IByteSerializer<Models.PAK.File>
{
/// <inheritdoc/>
#if NET48
public Models.PAK.File Deserialize(byte[] data, int offset)
#else
public Models.PAK.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.PAK().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.PFF;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class PFF : IByteSerializer<Archive>
{
/// <inheritdoc/>
#if NET48
public Archive Deserialize(byte[] data, int offset)
#else
public Archive? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.PFF().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.PlayJ;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class PlayJAudio : IByteSerializer<AudioFile>
{
/// <inheritdoc/>
#if NET48
public AudioFile Deserialize(byte[] data, int offset)
#else
public AudioFile? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.PlayJAudio().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.PlayJ;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class PlayJPlaylist : IByteSerializer<Playlist>
{
/// <inheritdoc/>
#if NET48
public Playlist Deserialize(byte[] data, int offset)
#else
public Playlist? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.PlayJPlaylist().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.PortableExecutable;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class PortableExecutable : IByteSerializer<Executable>
{
/// <inheritdoc/>
#if NET48
public Executable Deserialize(byte[] data, int offset)
#else
public Executable? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.PortableExecutable().Deserialize(dataStream);
}
}
}

View File

@@ -1,29 +0,0 @@
using System.IO;
using SabreTools.Models.Quantum;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class Quantum : IByteSerializer<Archive>
{
/// <inheritdoc/>
#if NET48
public Archive Deserialize(byte[] data, int offset)
#else
public Archive? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.Quantum().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class SGA : IByteSerializer<Models.SGA.File>
{
/// <inheritdoc/>
#if NET48
public Models.SGA.File Deserialize(byte[] data, int offset)
#else
public Models.SGA.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.SGA().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class VBSP : IByteSerializer<Models.VBSP.File>
{
/// <inheritdoc/>
#if NET48
public Models.VBSP.File Deserialize(byte[] data, int offset)
#else
public Models.VBSP.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.VBSP().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class VPK : IByteSerializer<Models.VPK.File>
{
/// <inheritdoc/>
#if NET48
public Models.VPK.File Deserialize(byte[] data, int offset)
#else
public Models.VPK.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.VPK().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class WAD : IByteSerializer<Models.WAD.File>
{
/// <inheritdoc/>
#if NET48
public Models.WAD.File Deserialize(byte[] data, int offset)
#else
public Models.WAD.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.WAD().Deserialize(dataStream);
}
}
}

View File

@@ -1,28 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Bytes
{
public partial class XZP : IByteSerializer<Models.XZP.File>
{
/// <inheritdoc/>
#if NET48
public Models.XZP.File Deserialize(byte[] data, int offset)
#else
public Models.XZP.File? Deserialize(byte[]? data, int offset)
#endif
{
// If the data is invalid
if (data == null)
return null;
// If the offset is out of bounds
if (offset < 0 || offset >= data.Length)
return null;
// Create a memory stream and parse that
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
return new Streams.XZP().Deserialize(dataStream);
}
}
}

View File

@@ -1,13 +0,0 @@
namespace SabreTools.Serialization
{
public enum Hash
{
CRC,
MD5,
SHA1,
SHA256,
SHA384,
SHA512,
SpamSum,
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class ArchiveDotOrg : XmlFile<Models.ArchiveDotOrg.Files>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class ArchiveDotOrg : XmlFile<Models.ArchiveDotOrg.Files>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.AttractMode;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class AttractMode : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path)
#else
public MetadataFile? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.AttractMode().Deserialize(stream);
}
}
}
}

View File

@@ -1,32 +0,0 @@
using System.IO;
using SabreTools.Models.AttractMode;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class AttractMode : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path)
#else
public bool Serialize(MetadataFile? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.AttractMode().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,28 +0,0 @@
using SabreTools.Models.ClrMamePro;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class ClrMamePro : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path) => Deserialize(path, true);
#else
public MetadataFile? Deserialize(string? path) => Deserialize(path, true);
#endif
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path, bool quotes)
#else
public MetadataFile? Deserialize(string? path, bool quotes)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.ClrMamePro().Deserialize(stream, quotes);
}
}
}
}

View File

@@ -1,39 +0,0 @@
using System.IO;
using SabreTools.Models.ClrMamePro;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class ClrMamePro : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path) => Serialize(obj, path, true);
#else
public bool Serialize(MetadataFile? obj, string? path) => Serialize(obj, path, true);
#endif
/// <inheritdoc cref="Serialize(MetadataFile, string)"/>
#if NET48
public bool Serialize(MetadataFile obj, string path, bool quotes)
#else
public bool Serialize(MetadataFile? obj, string? path, bool quotes)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.ClrMamePro().Serialize(obj, quotes))
{
if (stream == null)
return false;
using (var fs = File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,31 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class CueSheet : IFileSerializer<Models.CueSheets.CueSheet>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(Models.CueSheets.CueSheet obj, string path)
#else
public bool Serialize(Models.CueSheets.CueSheet? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.CueSheet().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.DosCenter;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class DosCenter : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path)
#else
public MetadataFile? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.DosCenter().Deserialize(stream);
}
}
}
}

View File

@@ -1,31 +0,0 @@
using SabreTools.Models.DosCenter;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class DosCenter : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path)
#else
public bool Serialize(MetadataFile? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.DosCenter().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.EverdriveSMDB;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class EverdriveSMDB : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path)
#else
public MetadataFile? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.EverdriveSMDB().Deserialize(stream);
}
}
}
}

View File

@@ -1,31 +0,0 @@
using SabreTools.Models.EverdriveSMDB;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class EverdriveSMDB : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path)
#else
public bool Serialize(MetadataFile? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.EverdriveSMDB().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,27 +0,0 @@
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class Hashfile : IFileSerializer<Models.Hashfile.Hashfile>
{
/// <inheritdoc/>
#if NET48
public Models.Hashfile.Hashfile Deserialize(string path) => Deserialize(path, Hash.CRC);
#else
public Models.Hashfile.Hashfile? Deserialize(string? path) => Deserialize(path, Hash.CRC);
#endif
/// <inheritdoc/>
#if NET48
public Models.Hashfile.Hashfile Deserialize(string path, Hash hash)
#else
public Models.Hashfile.Hashfile? Deserialize(string? path, Hash hash)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.Hashfile().Deserialize(stream, hash);
}
}
}
}

View File

@@ -1,37 +0,0 @@
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class Hashfile : IFileSerializer<Models.Hashfile.Hashfile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(Models.Hashfile.Hashfile obj, string path) => Serialize(obj, path, Hash.CRC);
#else
public bool Serialize(Models.Hashfile.Hashfile? obj, string? path) => Serialize(obj, path, Hash.CRC);
#endif
/// <inheritdoc/>
#if NET48
public bool Serialize(Models.Hashfile.Hashfile obj, string path, Hash hash)
#else
public bool Serialize(Models.Hashfile.Hashfile? obj, string? path, Hash hash)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.Hashfile().Serialize(obj, hash))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.Listrom;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class Listrom : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path)
#else
public MetadataFile? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.Listrom().Deserialize(stream);
}
}
}
}

View File

@@ -1,31 +0,0 @@
using SabreTools.Models.Listrom;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class Listrom : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path)
#else
public bool Serialize(MetadataFile? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.Listrom().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class Listxml : XmlFile<Models.Listxml.Mame>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class Listxml : XmlFile<Models.Listxml.Mame>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class Logiqx : XmlFile<Models.Logiqx.Datafile>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,11 +0,0 @@
using SabreTools.Models.Logiqx;
namespace SabreTools.Serialization.Files
{
public partial class Logiqx : XmlFile<Datafile>
{
/// <inheritdoc cref="Serialize(Datafile, string, string?, string?, string?, string?)" />
public bool SerializeToFileWithDocType(Datafile obj, string path)
=> Serialize(obj, path, Serialization.Logiqx.DocTypeName, Serialization.Logiqx.DocTypePubId, Serialization.Logiqx.DocTypeSysId, Serialization.Logiqx.DocTypeSysId);
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class M1 : XmlFile<Models.Listxml.M1>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class M1 : XmlFile<Models.Listxml.M1>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class OfflineList : XmlFile<Models.OfflineList.Dat>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class OfflineList : XmlFile<Models.OfflineList.Dat>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class OpenMSX : XmlFile<Models.OpenMSX.SoftwareDb>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,11 +0,0 @@
using SabreTools.Models.OpenMSX;
namespace SabreTools.Serialization.Files
{
public partial class OpenMSX : XmlFile<SoftwareDb>
{
/// <inheritdoc cref="Serialize(SoftwareDb, string, string?, string?, string?, string?)" />
public bool SerializeToFileWithDocType(SoftwareDb obj, string path)
=> Serialize(obj, path, Serialization.OpenMSX.DocTypeName, Serialization.OpenMSX.DocTypePubId, Serialization.OpenMSX.DocTypeSysId, Serialization.OpenMSX.DocTypeSysId);
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.PIC;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class PIC : IFileSerializer<DiscInformation>
{
/// <inheritdoc/>
#if NET48
public DiscInformation Deserialize(string path)
#else
public DiscInformation? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.PIC().Deserialize(stream);
}
}
}
}

View File

@@ -1,31 +0,0 @@
using SabreTools.Models.PIC;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class PIC : IFileSerializer<DiscInformation>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(DiscInformation obj, string path)
#else
public bool Serialize(DiscInformation? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.PIC().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,21 +0,0 @@
using SabreTools.Models.RomCenter;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class RomCenter : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path)
#else
public MetadataFile? Deserialize(string? path)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.RomCenter().Deserialize(stream);
}
}
}
}

View File

@@ -1,31 +0,0 @@
using SabreTools.Models.RomCenter;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class RomCenter : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path)
#else
public bool Serialize(MetadataFile? obj, string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.RomCenter().Serialize(obj))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,28 +0,0 @@
using SabreTools.Models.SeparatedValue;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class SeparatedValue : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path) => Deserialize(path, ',');
#else
public MetadataFile? Deserialize(string? path) => Deserialize(path, ',');
#endif
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(string path, char delim)
#else
public MetadataFile? Deserialize(string? path, char delim)
#endif
{
using (var stream = PathProcessor.OpenStream(path))
{
return new Streams.SeparatedValue().Deserialize(stream, delim);
}
}
}
}

View File

@@ -1,38 +0,0 @@
using SabreTools.Models.SeparatedValue;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class SeparatedValue : IFileSerializer<MetadataFile>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path) => Serialize(obj, path, ',');
#else
public bool Serialize(MetadataFile? obj, string? path) => Serialize(obj, path, ',');
#endif
/// <inheritdoc/>
#if NET48
public bool Serialize(MetadataFile obj, string path, char delim)
#else
public bool Serialize(MetadataFile? obj, string? path, char delim)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.SeparatedValue().Serialize(obj, delim))
{
if (stream == null)
return false;
using (var fs = System.IO.File.OpenWrite(path))
{
stream.CopyTo(fs);
return true;
}
}
}
}
}

View File

@@ -1,7 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class SoftwareList : XmlFile<Models.SoftwareList.SoftwareList>
{
// All serialization logic is in the base class
}
}

View File

@@ -1,9 +0,0 @@
namespace SabreTools.Serialization.Files
{
public partial class SoftwareList : XmlFile<Models.SoftwareList.SoftwareList>
{
/// <inheritdoc cref="SerializeToFile(Models.SoftwareList.SoftwareList, string, string?, string?, string?, string?)" />
public bool SerializeToFileWithDocType(Models.SoftwareList.SoftwareList obj, string path)
=> Serialize(obj, path, Serialization.SoftawreList.DocTypeName, Serialization.SoftawreList.DocTypePubId, Serialization.SoftawreList.DocTypeSysId, Serialization.SoftawreList.DocTypeSysId);
}
}

View File

@@ -1,216 +0,0 @@
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class XMID : IFileSerializer<Models.Xbox.XMID>
{
/// <inheritdoc/>
/// <remarks>This treats the input path like a parseable string</remarks>
#if NET48
public Models.Xbox.XMID Deserialize(string path)
#else
public Models.Xbox.XMID? Deserialize(string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return null;
string xmid = path.TrimEnd('\0');
if (string.IsNullOrWhiteSpace(xmid))
return null;
return ParseXMID(xmid);
}
/// <summary>
/// Parse an XGD2/3 XMID string
/// </summary>
/// <param name="xmidString">XMID string to attempt to parse</param>
/// <returns>Filled XMID on success, null on error</returns>
#if NET48
private static Models.Xbox.XMID ParseXMID(string xmidString)
#else
private static Models.Xbox.XMID? ParseXMID(string? xmidString)
#endif
{
if (xmidString == null || xmidString.Length != 8)
return null;
var xmid = new Models.Xbox.XMID();
xmid.PublisherIdentifier = xmidString.Substring(0, 2);
if (string.IsNullOrEmpty(PublisherName(xmid)))
return null;
xmid.GameID = xmidString.Substring(2, 3);
xmid.VersionNumber = xmidString.Substring(5, 2);
xmid.RegionIdentifier = xmidString[7];
if (InternalRegion(xmid) == null)
return null;
return xmid;
}
#region Helpers
/// <summary>
/// Human-readable name derived from the publisher identifier
/// </summary>
#if NET48
public static string PublisherName(Models.Xbox.XMID xmid) => GetPublisher(xmid.PublisherIdentifier);
#else
public static string? PublisherName(Models.Xbox.XMID xmid) => GetPublisher(xmid.PublisherIdentifier);
#endif
/// <summary>
/// Internally represented region
/// </summary>
#if NET48
public static string InternalRegion(Models.Xbox.XMID xmid) => GetRegion(xmid.RegionIdentifier);
#else
public static string? InternalRegion(Models.Xbox.XMID xmid) => GetRegion(xmid.RegionIdentifier);
#endif
/// <summary>
/// Get the full name of the publisher from the 2-character identifier
/// </summary>
/// <param name="publisherIdentifier">Case-sensitive 2-character identifier</param>
/// <returns>Publisher name, if possible</returns>
/// <see cref="https://xboxdevwiki.net/Xbe#Title_ID"/>
#if NET48
private static string GetPublisher(string publisherIdentifier)
#else
private static string? GetPublisher(string? publisherIdentifier)
#endif
{
switch (publisherIdentifier)
{
case "AC": return "Acclaim Entertainment";
case "AH": return "ARUSH Entertainment";
case "AQ": return "Aqua System";
case "AS": return "ASK";
case "AT": return "Atlus";
case "AV": return "Activision";
case "AY": return "Aspyr Media";
case "BA": return "Bandai";
case "BL": return "Black Box";
case "BM": return "BAM! Entertainment";
case "BR": return "Broccoli Co.";
case "BS": return "Bethesda Softworks";
case "BU": return "Bunkasha Co.";
case "BV": return "Buena Vista Games";
case "BW": return "BBC Multimedia";
case "BZ": return "Blizzard";
case "CC": return "Capcom";
case "CK": return "Kemco Corporation"; // TODO: Confirm
case "CM": return "Codemasters";
case "CV": return "Crave Entertainment";
case "DC": return "DreamCatcher Interactive";
case "DX": return "Davilex";
case "EA": return "Electronic Arts (EA)";
case "EC": return "Encore inc";
case "EL": return "Enlight Software";
case "EM": return "Empire Interactive";
case "ES": return "Eidos Interactive";
case "FI": return "Fox Interactive";
case "FS": return "From Software";
case "GE": return "Genki Co.";
case "GV": return "Groove Games";
case "HE": return "Tru Blu (Entertainment division of Home Entertainment Suppliers)";
case "HP": return "Hip games";
case "HU": return "Hudson Soft";
case "HW": return "Highwaystar";
case "IA": return "Mad Catz Interactive";
case "IF": return "Idea Factory";
case "IG": return "Infogrames";
case "IL": return "Interlex Corporation";
case "IM": return "Imagine Media";
case "IO": return "Ignition Entertainment";
case "IP": return "Interplay Entertainment";
case "IX": return "InXile Entertainment"; // TODO: Confirm
case "JA": return "Jaleco";
case "JW": return "JoWooD";
case "KB": return "Kemco"; // TODO: Confirm
case "KI": return "Kids Station Inc."; // TODO: Confirm
case "KN": return "Konami";
case "KO": return "KOEI";
case "KU": return "Kobi and / or GAE (formerly Global A Entertainment)"; // TODO: Confirm
case "LA": return "LucasArts";
case "LS": return "Black Bean Games (publishing arm of Leader S.p.A.)";
case "MD": return "Metro3D";
case "ME": return "Medix";
case "MI": return "Microïds";
case "MJ": return "Majesco Entertainment";
case "MM": return "Myelin Media";
case "MP": return "MediaQuest"; // TODO: Confirm
case "MS": return "Microsoft Game Studios";
case "MW": return "Midway Games";
case "MX": return "Empire Interactive"; // TODO: Confirm
case "NK": return "NewKidCo";
case "NL": return "NovaLogic";
case "NM": return "Namco";
case "OX": return "Oxygen Interactive";
case "PC": return "Playlogic Entertainment";
case "PL": return "Phantagram Co., Ltd.";
case "RA": return "Rage";
case "SA": return "Sammy";
case "SC": return "SCi Games";
case "SE": return "SEGA";
case "SN": return "SNK";
case "SS": return "Simon & Schuster";
case "SU": return "Success Corporation";
case "SW": return "Swing! Deutschland";
case "TA": return "Takara";
case "TC": return "Tecmo";
case "TD": return "The 3DO Company (or just 3DO)";
case "TK": return "Takuyo";
case "TM": return "TDK Mediactive";
case "TQ": return "THQ";
case "TS": return "Titus Interactive";
case "TT": return "Take-Two Interactive Software";
case "US": return "Ubisoft";
case "VC": return "Victor Interactive Software";
case "VN": return "Vivendi Universal (just took Interplays publishing rights)"; // TODO: Confirm
case "VU": return "Vivendi Universal Games";
case "VV": return "Vivendi Universal Games"; // TODO: Confirm
case "WE": return "Wanadoo Edition";
case "WR": return "Warner Bros. Interactive Entertainment"; // TODO: Confirm
case "XI": return "XPEC Entertainment and Idea Factory";
case "XK": return "Xbox kiosk disk?"; // TODO: Confirm
case "XL": return "Xbox special bundled or live demo disk?"; // TODO: Confirm
case "XM": return "Evolved Games"; // TODO: Confirm
case "XP": return "XPEC Entertainment";
case "XR": return "Panorama";
case "YB": return "YBM Sisa (South-Korea)";
case "ZD": return "Zushi Games (formerly Zoo Digital Publishing)";
default: return null;
}
}
/// <summary>
/// Determine the region based on the XGD serial character
/// </summary>
/// <param name="region">Character denoting the region</param>
/// <returns>Region, if possible</returns>
#if NET48
private static string GetRegion(char region)
#else
private static string? GetRegion(char region)
#endif
{
switch (region)
{
case 'W': return "World";
case 'A': return "USA";
case 'J': return "Japan / Asia";
case 'E': return "Europe";
case 'K': return "USA / Japan";
case 'L': return "USA / Europe";
case 'H': return "Japan / Europe";
default: return null;
}
}
#endregion
}
}

View File

@@ -1,15 +0,0 @@
using System;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class XMID : IFileSerializer<Models.Xbox.XMID>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(Models.Xbox.XMID obj, string path) => throw new NotImplementedException();
#else
public bool Serialize(Models.Xbox.XMID? obj, string? path) => throw new NotImplementedException();
#endif
}
}

View File

@@ -1,275 +0,0 @@
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class XeMID : IFileSerializer<Models.Xbox.XeMID>
{
/// <inheritdoc/>
/// <remarks>This treats the input path like a parseable string</remarks>
#if NET48
public Models.Xbox.XeMID Deserialize(string path)
#else
public Models.Xbox.XeMID? Deserialize(string? path)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return null;
string xemid = path.TrimEnd('\0');
if (string.IsNullOrWhiteSpace(xemid))
return null;
return ParseXeMID(xemid);
}
/// <summary>
/// Parse an XGD2/3 XeMID string
/// </summary>
/// <param name="xemidString">XeMID string to attempt to parse</param>
/// <returns>Filled XeMID on success, null on error</returns>
#if NET48
private static Models.Xbox.XeMID ParseXeMID(string xemidString)
#else
private static Models.Xbox.XeMID? ParseXeMID(string? xemidString)
#endif
{
if (xemidString == null
|| (xemidString.Length != 13 && xemidString.Length != 14
&& xemidString.Length != 21 && xemidString.Length != 22))
return null;
var xemid = new Models.Xbox.XeMID();
xemid.PublisherIdentifier = xemidString.Substring(0, 2);
if (string.IsNullOrEmpty(PublisherName(xemid)))
return null;
xemid.PlatformIdentifier = xemidString[2];
if (xemid.PlatformIdentifier != '2')
return null;
xemid.GameID = xemidString.Substring(3, 3);
xemid.SKU = xemidString.Substring(6, 2);
xemid.RegionIdentifier = xemidString[8];
if (InternalRegion(xemid) == null)
return null;
if (xemidString.Length == 13 || xemidString.Length == 21)
{
xemid.BaseVersion = xemidString.Substring(9, 1);
xemid.MediaSubtypeIdentifier = xemidString[10];
if (string.IsNullOrEmpty(MediaSubtype(xemid)))
return null;
xemid.DiscNumberIdentifier = xemidString.Substring(11, 2);
}
else if (xemidString.Length == 14 || xemidString.Length == 22)
{
xemid.BaseVersion = xemidString.Substring(9, 2);
xemid.MediaSubtypeIdentifier = xemidString[11];
if (string.IsNullOrEmpty(MediaSubtype(xemid)))
return null;
xemid.DiscNumberIdentifier = xemidString.Substring(12, 2);
}
if (xemidString.Length == 21)
xemid.CertificationSubmissionIdentifier = xemidString.Substring(13);
else if (xemidString.Length == 22)
xemid.CertificationSubmissionIdentifier = xemidString.Substring(14);
return xemid;
}
#region Helpers
/// <summary>
/// Human-readable name derived from the publisher identifier
/// </summary>
#if NET48
public static string PublisherName(Models.Xbox.XeMID xemid) => GetPublisher(xemid.PublisherIdentifier);
#else
public static string? PublisherName(Models.Xbox.XeMID xemid) => GetPublisher(xemid.PublisherIdentifier);
#endif
/// <summary>
/// Internally represented region
/// </summary>
#if NET48
public static string InternalRegion(Models.Xbox.XeMID xemid) => GetRegion(xemid.RegionIdentifier);
#else
public static string? InternalRegion(Models.Xbox.XeMID xemid) => GetRegion(xemid.RegionIdentifier);
#endif
/// <summary>
/// Human-readable subtype derived from the media identifier
/// </summary>
#if NET48
public static string MediaSubtype(Models.Xbox.XeMID xemid) => GetMediaSubtype(xemid.MediaSubtypeIdentifier);
#else
public static string? MediaSubtype(Models.Xbox.XeMID xemid) => GetMediaSubtype(xemid.MediaSubtypeIdentifier);
#endif
/// <summary>
/// Determine the XGD type based on the XGD2/3 media type identifier character
/// </summary>
/// <param name="mediaTypeIdentifier">Character denoting the media type</param>
/// <returns>Media subtype as a string, if possible</returns>
#if NET48
private static string GetMediaSubtype(char mediaTypeIdentifier)
#else
private static string? GetMediaSubtype(char mediaTypeIdentifier)
#endif
{
switch (mediaTypeIdentifier)
{
case 'F': return "XGD3";
case 'X': return "XGD2";
case 'Z': return "Games on Demand / Marketplace Demo";
default: return null;
}
}
/// <summary>
/// Get the full name of the publisher from the 2-character identifier
/// </summary>
/// <param name="publisherIdentifier">Case-sensitive 2-character identifier</param>
/// <returns>Publisher name, if possible</returns>
/// <see cref="https://xboxdevwiki.net/Xbe#Title_ID"/>
#if NET48
private static string GetPublisher(string publisherIdentifier)
#else
private static string? GetPublisher(string? publisherIdentifier)
#endif
{
switch (publisherIdentifier)
{
case "AC": return "Acclaim Entertainment";
case "AH": return "ARUSH Entertainment";
case "AQ": return "Aqua System";
case "AS": return "ASK";
case "AT": return "Atlus";
case "AV": return "Activision";
case "AY": return "Aspyr Media";
case "BA": return "Bandai";
case "BL": return "Black Box";
case "BM": return "BAM! Entertainment";
case "BR": return "Broccoli Co.";
case "BS": return "Bethesda Softworks";
case "BU": return "Bunkasha Co.";
case "BV": return "Buena Vista Games";
case "BW": return "BBC Multimedia";
case "BZ": return "Blizzard";
case "CC": return "Capcom";
case "CK": return "Kemco Corporation"; // TODO: Confirm
case "CM": return "Codemasters";
case "CV": return "Crave Entertainment";
case "DC": return "DreamCatcher Interactive";
case "DX": return "Davilex";
case "EA": return "Electronic Arts (EA)";
case "EC": return "Encore inc";
case "EL": return "Enlight Software";
case "EM": return "Empire Interactive";
case "ES": return "Eidos Interactive";
case "FI": return "Fox Interactive";
case "FS": return "From Software";
case "GE": return "Genki Co.";
case "GV": return "Groove Games";
case "HE": return "Tru Blu (Entertainment division of Home Entertainment Suppliers)";
case "HP": return "Hip games";
case "HU": return "Hudson Soft";
case "HW": return "Highwaystar";
case "IA": return "Mad Catz Interactive";
case "IF": return "Idea Factory";
case "IG": return "Infogrames";
case "IL": return "Interlex Corporation";
case "IM": return "Imagine Media";
case "IO": return "Ignition Entertainment";
case "IP": return "Interplay Entertainment";
case "IX": return "InXile Entertainment"; // TODO: Confirm
case "JA": return "Jaleco";
case "JW": return "JoWooD";
case "KB": return "Kemco"; // TODO: Confirm
case "KI": return "Kids Station Inc."; // TODO: Confirm
case "KN": return "Konami";
case "KO": return "KOEI";
case "KU": return "Kobi and / or GAE (formerly Global A Entertainment)"; // TODO: Confirm
case "LA": return "LucasArts";
case "LS": return "Black Bean Games (publishing arm of Leader S.p.A.)";
case "MD": return "Metro3D";
case "ME": return "Medix";
case "MI": return "Microïds";
case "MJ": return "Majesco Entertainment";
case "MM": return "Myelin Media";
case "MP": return "MediaQuest"; // TODO: Confirm
case "MS": return "Microsoft Game Studios";
case "MW": return "Midway Games";
case "MX": return "Empire Interactive"; // TODO: Confirm
case "NK": return "NewKidCo";
case "NL": return "NovaLogic";
case "NM": return "Namco";
case "OX": return "Oxygen Interactive";
case "PC": return "Playlogic Entertainment";
case "PL": return "Phantagram Co., Ltd.";
case "RA": return "Rage";
case "SA": return "Sammy";
case "SC": return "SCi Games";
case "SE": return "SEGA";
case "SN": return "SNK";
case "SS": return "Simon & Schuster";
case "SU": return "Success Corporation";
case "SW": return "Swing! Deutschland";
case "TA": return "Takara";
case "TC": return "Tecmo";
case "TD": return "The 3DO Company (or just 3DO)";
case "TK": return "Takuyo";
case "TM": return "TDK Mediactive";
case "TQ": return "THQ";
case "TS": return "Titus Interactive";
case "TT": return "Take-Two Interactive Software";
case "US": return "Ubisoft";
case "VC": return "Victor Interactive Software";
case "VN": return "Vivendi Universal (just took Interplays publishing rights)"; // TODO: Confirm
case "VU": return "Vivendi Universal Games";
case "VV": return "Vivendi Universal Games"; // TODO: Confirm
case "WE": return "Wanadoo Edition";
case "WR": return "Warner Bros. Interactive Entertainment"; // TODO: Confirm
case "XI": return "XPEC Entertainment and Idea Factory";
case "XK": return "Xbox kiosk disk?"; // TODO: Confirm
case "XL": return "Xbox special bundled or live demo disk?"; // TODO: Confirm
case "XM": return "Evolved Games"; // TODO: Confirm
case "XP": return "XPEC Entertainment";
case "XR": return "Panorama";
case "YB": return "YBM Sisa (South-Korea)";
case "ZD": return "Zushi Games (formerly Zoo Digital Publishing)";
default: return null;
}
}
/// <summary>
/// Determine the region based on the XGD serial character
/// </summary>
/// <param name="region">Character denoting the region</param>
/// <returns>Region, if possible</returns>
#if NET48
private static string GetRegion(char region)
#else
private static string? GetRegion(char region)
#endif
{
switch (region)
{
case 'W': return "World";
case 'A': return "USA";
case 'J': return "Japan / Asia";
case 'E': return "Europe";
case 'K': return "USA / Japan";
case 'L': return "USA / Europe";
case 'H': return "Japan / Europe";
default: return null;
}
}
#endregion
}
}

View File

@@ -1,15 +0,0 @@
using System;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
public partial class XeMID : IFileSerializer<Models.Xbox.XeMID>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(Models.Xbox.XeMID obj, string path) => throw new NotImplementedException();
#else
public bool Serialize(Models.Xbox.XeMID? obj, string? path) => throw new NotImplementedException();
#endif
}
}

View File

@@ -1,24 +0,0 @@
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
/// <summary>
/// Base class for other XML serializers
/// </summary>
/// <typeparam name="T"></typeparam>
public partial class XmlFile<T> : IFileSerializer<T>
{
/// <inheritdoc/>
#if NET48
public T Deserialize(string path)
#else
public T? Deserialize(string? path)
#endif
{
using (var data = PathProcessor.OpenStream(path))
{
return new Streams.XmlFile<T>().Deserialize(data);
}
}
}
}

View File

@@ -1,54 +0,0 @@
using System.IO;
using SabreTools.Serialization.Interfaces;
namespace SabreTools.Serialization.Files
{
/// <summary>
/// Base class for other XML serializers
/// </summary>
/// <typeparam name="T"></typeparam>
public partial class XmlFile<T> : IFileSerializer<T>
{
/// <inheritdoc/>
#if NET48
public bool Serialize(T obj, string path)
#else
public bool Serialize(T? obj, string? path)
#endif
=> Serialize(obj, path, null, null, null, null);
/// <summary>
/// Serializes the defined type to an XML file
/// </summary>
/// <param name="obj">Data to serialize</param>
/// <param name="path">Path to the file to serialize to</param>
/// <param name="obj">Data to serialize</param>
/// <param name="name">Optional DOCTYPE name</param>
/// <param name="pubid">Optional DOCTYPE pubid</param>
/// <param name="sysid">Optional DOCTYPE sysid</param>
/// <param name="subset">Optional DOCTYPE name</param>
/// <returns>True on successful serialization, false otherwise</returns>
#if NET48
public bool Serialize(T obj, string path, string name = null, string pubid = null, string sysid = null, string subset = null)
#else
public bool Serialize(T? obj, string? path, string? name = null, string? pubid = null, string? sysid = null, string? subset = null)
#endif
{
if (string.IsNullOrWhiteSpace(path))
return false;
using (var stream = new Streams.XmlFile<T>().Serialize(obj, name, pubid, sysid, subset))
{
if (stream == null)
return false;
using (var fs = File.OpenWrite(path))
{
stream.CopyTo(fs);
}
return true;
}
}
}
}

View File

@@ -1,33 +0,0 @@
namespace SabreTools.Serialization.Interfaces
{
/// <summary>
/// Defines how to serialize to and from files
/// </summary>
public interface IFileSerializer<T>
{
/// <summary>
/// Deserialize a file into <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T">Type of object to deserialize to</typeparam>
/// <param name="path">Path to deserialize from</param>
/// <returns>Filled object on success, null on error</returns>
#if NET48
T Deserialize(string path);
#else
T? Deserialize(string? path);
#endif
/// <summary>
/// Sserialize a <typeparamref name="T"/> into a file
/// </summary>
/// <typeparam name="T">Type of object to serialize from</typeparam>
/// <param name="obj">Data to serialize</param>
/// <param name="path">Path to the file to serialize to</param>
/// <returns>True on successful serialization, false otherwise</returns>
#if NET48
bool Serialize(T obj, string path);
#else
bool Serialize(T? obj, string? path);
#endif
}
}

View File

@@ -1,34 +0,0 @@
using System.IO;
namespace SabreTools.Serialization.Interfaces
{
/// <summary>
/// Defines how to serialize to and from Streams
/// </summary>
public interface IStreamSerializer<T>
{
/// <summary>
/// Deserialize a Stream into <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T">Type of object to deserialize to</typeparam>
/// <param name="data">Stream to parse</param>
/// <returns>Filled object on success, null on error</returns>
#if NET48
T Deserialize(Stream data);
#else
T? Deserialize(Stream? data);
#endif
/// <summary>
/// Serialize a <typeparamref name="T"/> into a Stream
/// </summary>
/// <typeparam name="T">Type of object to serialize from</typeparam>
/// <param name="obj">Data to serialize</param>
/// <returns>Filled object on success, null on error</returns>
#if NET48
Stream Serialize(T obj);
#else
Stream? Serialize(T? obj);
#endif
}
}

View File

@@ -1,107 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using SabreTools.Models.Metadata;
namespace SabreTools.Serialization
{
public static class Internal
{
/// <summary>
/// Extract nested items from a Dump
/// </summary>
#if NET48
public static DatItem[] ExtractItems(Dump item)
#else
public static DatItem[]? ExtractItems(Dump? item)
#endif
{
if (item == null)
return null;
var datItems = new List<DatItem>();
var rom = item.Read<Rom>(Dump.RomKey);
if (rom != null)
datItems.Add(rom);
var megaRom = item.Read<Rom>(Dump.MegaRomKey);
if (megaRom != null)
datItems.Add(megaRom);
var sccPlusCart = item.Read<Rom>(Dump.SCCPlusCartKey);
if (sccPlusCart != null)
datItems.Add(sccPlusCart);
return datItems.ToArray();
}
/// <summary>
/// Extract nested items from a Part
/// </summary>
#if NET48
public static DatItem[] ExtractItems(Part item)
#else
public static DatItem[]? ExtractItems(Part? item)
#endif
{
if (item == null)
return null;
var datItems = new List<DatItem>();
var features = item.Read<Feature[]>(Part.FeatureKey);
if (features != null && features.Any())
datItems.AddRange(features);
var dataAreas = item.Read<DataArea[]>(Part.DataAreaKey);
if (dataAreas != null && dataAreas.Any())
{
datItems.AddRange(dataAreas
.Where(d => d != null)
.SelectMany(ExtractItems));
}
var diskAreas = item.Read<DiskArea[]>(Part.DiskAreaKey);
if (diskAreas != null && diskAreas.Any())
{
datItems.AddRange(diskAreas
.Where(d => d != null)
.SelectMany(ExtractItems));
}
var dipSwitches = item.Read<DipSwitch[]>(Part.DipSwitchKey);
if (dipSwitches != null && dipSwitches.Any())
{
datItems.AddRange(dipSwitches
.Where(d => d != null));
}
return datItems.ToArray();
}
/// <summary>
/// Extract nested items from a DataArea
/// </summary>
private static Rom[] ExtractItems(DataArea item)
{
var roms = item.Read<Rom[]>(DataArea.RomKey);
if (roms == null || !roms.Any())
return Array.Empty<Rom>();
return roms.ToArray();
}
/// <summary>
/// Extract nested items from a DiskArea
/// </summary>
private static Disk[] ExtractItems(DiskArea item)
{
var roms = item.Read<Disk[]>(DiskArea.DiskKey);
if (roms == null || !roms.Any())
return Array.Empty<Disk>();
return roms.ToArray();
}
}
}

View File

@@ -1,32 +0,0 @@
namespace SabreTools.Serialization
{
/// <summary>
/// XML deserializer for Logiqx-derived metadata files
/// </summary>
public static class Logiqx
{
/// <summary>
/// name field for DOCTYPE
/// </summary>
public const string DocTypeName = "datafile";
/// <summary>
/// pubid field for DOCTYPE
/// </summary>
public const string DocTypePubId = "-//Logiqx//DTD ROM Management Datafile//EN";
/// <summary>
/// sysid field for DOCTYPE
/// </summary>
public const string DocTypeSysId = "http://www.logiqx.com/Dats/datafile.dtd";
/// <summary>
/// subset field for DOCTYPE
/// </summary>
#if NET48
public const string DocTypeSubset = null;
#else
public const string? DocTypeSubset = null;
#endif
}
}

View File

@@ -1,36 +0,0 @@
namespace SabreTools.Serialization
{
/// <summary>
/// XML deserializer for OpenMSX software database files
/// </summary>
public static class OpenMSX
{
/// <summary>
/// name field for DOCTYPE
/// </summary>
public const string DocTypeName = "softwaredb";
/// <summary>
/// pubid field for DOCTYPE
/// </summary>
#if NET48
public const string DocTypePubId = null;
#else
public const string? DocTypePubId = null;
#endif
/// <summary>
/// sysid field for DOCTYPE
/// </summary>
public const string DocTypeSysId = "softwaredb1.dtd";
/// <summary>
/// subset field for DOCTYPE
/// </summary>
#if NET48
public const string DocTypeSubset = null;
#else
public const string? DocTypeSubset = null;
#endif
}
}

View File

@@ -4,22 +4,30 @@ This library comprises of serializers that both read and write from files and st
Find the link to the Nuget package [here](https://www.nuget.org/packages/SabreTools.Serialization).
## `SabreTools.Serialization.Bytes`
## Interfaces
This namespace comprises of deserializers that take byte arrays to convert into models.
Below is a table representing the various interfaces that are implemented within this library.
## `SabreTools.Serialization.CrossModel`
| Interface Name | Source Type | Destination Type |
| --- | --- | --- |
| `IByteDeserializer` | `byte[]?` | Model |
| `IByteSerializer` | Model | `byte[]?` |
| `IFileDeserializer` | `string?` path | Model |
| `IFileSerializer` | Model | `string?` path |
| `IModelSerializer` | Model | Model |
| `IStreamDeserializer` | `Stream?` | Model |
| `IStreamSerializer` | Model | `Stream?` |
| `IStringDeserializer` | `string?` representation | Model |
| `IStringSerializer` | Model | `string?` representation |
| `IWrapper` | N/A | N/A |
This namespace comprises of serializers and deserializers that convert models to other common ones. This is mainly used for metadata files converting to and from a common, `Dictionary`-based model.
## Namespaces
## `SabreTools.Serialization.Files`
Below is a table of all namespaces within the library and what they represent
This namespace comprises of serializers and deserializers that can convert to and from files on disk. Most of the serializers are symmetric, but this is not guaranteed. Unimplemented methods will throw `NotImplementedException`.
## `SabreTools.Serialization.Streams`
This namespace comprises of serializers and deserializers that can convert to and from any type of stream. Most of the serializers are symmetric, but this is not guaranteed. Unimplemented methods will throw `NotImplementedException`.
## `SabreTools.Serialization.Wrappers`
This namespace comrpises of wrapping classes that include keeping a reference to the source of each serializable model. Some of the wrappers may also include what are referred to as "extension properties", which are generated properties derived from either parts of the model or the underlying source.
| Namespace | Description |
| --- | --- |
| `SabreTools.Serialization.CrossModel` | Convert between models; mainly used for metadata files converting to and from a common, `Dictionary`-based model |
| `SabreTools.Serialization.Deserializers` | Convert from external sources to models |
| `SabreTools.Serialization.Serializers` | Convert from models to external sources |
| `SabreTools.Serialization.Wrappers` | Classes that wrap serialization and models to allow for including extension properties |

View File

@@ -3,7 +3,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SabreTools.Serialization", "SabreTools.Serialization.csproj", "{5B688801-5F36-483E-B2E8-F219BA5923A2}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SabreTools.Serialization", "SabreTools.Serialization\SabreTools.Serialization.csproj", "{5B688801-5F36-483E-B2E8-F219BA5923A2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test", "Test\Test.csproj", "{F3DEE31A-4726-464C-A90C-C19D78F51898}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -18,5 +20,9 @@ Global
{5B688801-5F36-483E-B2E8-F219BA5923A2}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5B688801-5F36-483E-B2E8-F219BA5923A2}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5B688801-5F36-483E-B2E8-F219BA5923A2}.Release|Any CPU.Build.0 = Release|Any CPU
{F3DEE31A-4726-464C-A90C-C19D78F51898}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{F3DEE31A-4726-464C-A90C-C19D78F51898}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F3DEE31A-4726-464C-A90C-C19D78F51898}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F3DEE31A-4726-464C-A90C-C19D78F51898}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class ArchiveDotOrg : IModelSerializer<Models.ArchiveDotOrg.Files, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.ArchiveDotOrg.Files Deserialize(Models.Metadata.MetadataFile obj)
#else
public Models.ArchiveDotOrg.Files? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -38,7 +34,7 @@ namespace SabreTools.Serialization.CrossModel
{
var roms = item.Read<Models.Metadata.Rom[]>(Models.Metadata.Machine.RomKey);
if (roms == null)
return Array.Empty<File>();
return [];
return roms
.Where(r => r != null)

View File

@@ -6,15 +6,11 @@ namespace SabreTools.Serialization.CrossModel
public partial class ArchiveDotOrg : IModelSerializer<Models.ArchiveDotOrg.Files, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(Models.ArchiveDotOrg.Files item)
#else
public Models.Metadata.MetadataFile? Serialize(Models.ArchiveDotOrg.Files? item)
#endif
{
if (item == null)
return null;
var metadataFile = new Models.Metadata.MetadataFile
{
[Models.Metadata.MetadataFile.HeaderKey] = ConvertHeaderToInternalModel(item),
@@ -47,27 +43,21 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.ArchiveDotOrg.File"/> to <cref="Models.Metadata.Machine"/>
/// </summary>
#if NET48
private static Models.Metadata.Machine ConvertMachineToInternalModel(Models.ArchiveDotOrg.File item)
#else
private static Models.Metadata.Machine ConvertMachineToInternalModel(Models.ArchiveDotOrg.File? item)
#endif
{
var machine = new Models.Metadata.Machine
{
[Models.Metadata.Machine.RomKey] = ConvertToInternalModel(item),
};
var machine = new Models.Metadata.Machine();
var rom = ConvertToInternalModel(item);
if (rom != null)
machine[Models.Metadata.Machine.RomKey] = new Models.Metadata.Rom[] { rom };
return machine;
}
/// <summary>
/// Convert from <cref="Models.ArchiveDotOrg.File"/> to <cref="Models.Metadata.Rom"/>
/// </summary>
#if NET48
private static Models.Metadata.Rom ConvertToInternalModel(Models.ArchiveDotOrg.File item)
#else
private static Models.Metadata.Rom? ConvertToInternalModel(Models.ArchiveDotOrg.File? item)
#endif
{
if (item == null)
return null;

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class AttractMode : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj)
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -51,7 +47,7 @@ namespace SabreTools.Serialization.CrossModel
{
var roms = item.Read<Models.Metadata.Rom[]>(Models.Metadata.Machine.RomKey);
if (roms == null || !roms.Any())
return Array.Empty<Row>();
return [];
return roms
.Where(r => r != null)

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class AttractMode : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
#else
public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -48,11 +44,7 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.AttractMode.Row"/> to <cref="Models.Metadata.Machine"/>
/// </summary>
#if NET48
private static Models.Metadata.Machine ConvertMachineToInternalModel(Row item)
#else
private static Models.Metadata.Machine? ConvertMachineToInternalModel(Row? item)
#endif
{
if (item == null)
return null;

View File

@@ -7,18 +7,10 @@ namespace SabreTools.Serialization.CrossModel
public partial class ClrMamePro : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj) => Deserialize(obj, false);
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj) => Deserialize(obj, false);
#endif
/// <inheritdoc cref="Deserialize(Models.Metadata.MetadataFile)"/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj, bool game)
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj, bool game)
#endif
{
if (obj == null)
return null;
@@ -72,15 +64,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static GameBase ConvertMachineFromInternalModel(Models.Metadata.Machine item, bool game = false)
{
#if NET48
GameBase gameBase;
if (game)
gameBase = new Game();
else
gameBase = new Machine();
#else
GameBase gameBase = game ? new Models.ClrMamePro.Game() : new Models.ClrMamePro.Machine();
#endif
gameBase.Name = item.ReadString(Models.Metadata.Machine.NameKey);
gameBase.Description = item.ReadString(Models.Metadata.Machine.DescriptionKey);

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class ClrMamePro : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
#else
public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -62,11 +58,7 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.ClrMamePro.GameBase"/> to <cref="Models.Metadata.Machine"/>
/// </summary>
#if NET48
private static Models.Metadata.Machine ConvertMachineToInternalModel(GameBase item)
#else
private static Models.Metadata.Machine? ConvertMachineToInternalModel(GameBase? item)
#endif
{
if (item == null)
return null;

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class DosCenter : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj)
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class DosCenter : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
#else
public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class EverdriveSMDB : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj)
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -38,7 +34,7 @@ namespace SabreTools.Serialization.CrossModel
{
var roms = item.Read<Models.Metadata.Rom[]>(Models.Metadata.Machine.RomKey);
if (roms == null || !roms.Any())
return Array.Empty<Row>();
return [];
return roms
.Where(r => r != null)

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class EverdriveSMDB : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
#else
public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -1,5 +1,6 @@
using System.Collections.Generic;
using System.Linq;
using SabreTools.Hashing;
using SabreTools.Models.Hashfile;
using SabreTools.Serialization.Interfaces;
@@ -8,18 +9,10 @@ namespace SabreTools.Serialization.CrossModel
public partial class Hashfile : IModelSerializer<Models.Hashfile.Hashfile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Hashfile.Hashfile Deserialize(Models.Metadata.MetadataFile obj) => Deserialize(obj, Hash.CRC);
#else
public Models.Hashfile.Hashfile? Deserialize(Models.Metadata.MetadataFile? obj) => Deserialize(obj, Hash.CRC);
#endif
public Models.Hashfile.Hashfile? Deserialize(Models.Metadata.MetadataFile? obj) => Deserialize(obj, HashType.CRC32);
/// <inheritdoc/>
#if NET48
public Models.Hashfile.Hashfile Deserialize(Models.Metadata.MetadataFile obj, Hash hash)
#else
public Models.Hashfile.Hashfile? Deserialize(Models.Metadata.MetadataFile? obj, Hash hash)
#endif
public Models.Hashfile.Hashfile? Deserialize(Models.Metadata.MetadataFile? obj, HashType hash)
{
if (obj == null)
return null;
@@ -81,11 +74,7 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.Metadata.MetadataFile"/> to an array of <cref="Models.Hashfile.Hashfile"/>
/// </summary>
#if NET48
public static Models.Hashfile.Hashfile[] ConvertArrayFromInternalModel(Models.Metadata.MetadataFile item, Hash hash)
#else
public static Models.Hashfile.Hashfile[]? ConvertArrayFromInternalModel(Models.Metadata.MetadataFile? item, Hash hash)
#endif
public static Models.Hashfile.Hashfile[]? ConvertArrayFromInternalModel(Models.Metadata.MetadataFile? item, HashType hash)
{
if (item == null)
return null;
@@ -105,7 +94,7 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.Metadata.Machine"/> to <cref="Models.Hashfile.Hashfile"/>
/// </summary>
private static Models.Hashfile.Hashfile ConvertMachineFromInternalModel(Models.Metadata.Machine item, Hash hash)
private static Models.Hashfile.Hashfile ConvertMachineFromInternalModel(Models.Metadata.Machine item, HashType hash)
{
var roms = item.Read<Models.Metadata.Rom[]>(Models.Metadata.Machine.RomKey);
if (roms == null)
@@ -113,43 +102,43 @@ namespace SabreTools.Serialization.CrossModel
return new Models.Hashfile.Hashfile
{
SFV = hash == Hash.CRC
SFV = hash == HashType.CRC32 || hash == HashType.CRC32_ISO || hash == HashType.CRC32_Naive || hash == HashType.CRC32_Optimized || hash == HashType.CRC32_Parallel
? roms
.Where(r => r != null)
.Select(ConvertToSFV)
.ToArray()
: null,
MD5 = hash == Hash.MD5
MD5 = hash == HashType.MD5
? roms
.Where(r => r != null)
.Select(ConvertToMD5)
.ToArray()
: null,
SHA1 = hash == Hash.SHA1
SHA1 = hash == HashType.SHA1
? roms
.Where(r => r != null)
.Select(ConvertToSHA1)
.ToArray()
: null,
SHA256 = hash == Hash.SHA256
SHA256 = hash == HashType.SHA256
? roms
.Where(r => r != null)
.Select(ConvertToSHA256)
.ToArray()
: null,
SHA384 = hash == Hash.SHA384
SHA384 = hash == HashType.SHA384
? roms
.Where(r => r != null)
.Select(ConvertToSHA384)
.ToArray()
: null,
SHA512 = hash == Hash.SHA512
SHA512 = hash == HashType.SHA512
? roms
.Where(r => r != null)
.Select(ConvertToSHA512)
.ToArray()
: null,
SpamSum = hash == Hash.SpamSum
SpamSum = hash == HashType.SpamSum
? roms
.Where(r => r != null)
.Select(ConvertToSpamSum)

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class Hashfile : IModelSerializer<Models.Hashfile.Hashfile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(Models.Hashfile.Hashfile obj)
#else
public Models.Metadata.MetadataFile? Serialize(Models.Hashfile.Hashfile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class Listrom : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public MetadataFile Deserialize(Models.Metadata.MetadataFile obj)
#else
public MetadataFile? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class Listrom : IModelSerializer<MetadataFile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(MetadataFile obj)
#else
public Models.Metadata.MetadataFile? Serialize(MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -51,7 +47,7 @@ namespace SabreTools.Serialization.CrossModel
private static Models.Metadata.Machine ConvertMachineToInternalModel(Set item)
{
var machine = new Models.Metadata.Machine();
if (!string.IsNullOrWhiteSpace(item.Device))
if (!string.IsNullOrEmpty(item.Device))
{
machine[Models.Metadata.Machine.NameKey] = item.Device;
machine[Models.Metadata.Machine.IsDeviceKey] = "yes";
@@ -69,8 +65,8 @@ namespace SabreTools.Serialization.CrossModel
datItems.Add(ConvertToInternalModel(file));
}
machine[Models.Metadata.Machine.DiskKey] = datItems.Where(i => i.ReadString(Models.Metadata.DatItem.TypeKey) == "disk")?.ToArray();
machine[Models.Metadata.Machine.RomKey] = datItems.Where(i => i.ReadString(Models.Metadata.DatItem.TypeKey) == "rom")?.ToArray();
machine[Models.Metadata.Machine.DiskKey] = datItems.Where(i => i.ReadString(Models.Metadata.DatItem.TypeKey) == "disk").Select(d => d as Models.Metadata.Disk).ToArray();
machine[Models.Metadata.Machine.RomKey] = datItems.Where(i => i.ReadString(Models.Metadata.DatItem.TypeKey) == "rom").Select(d => d as Models.Metadata.Rom).ToArray();
}
return machine;
@@ -85,6 +81,7 @@ namespace SabreTools.Serialization.CrossModel
{
var disk = new Models.Metadata.Disk
{
[Models.Metadata.DatItem.TypeKey] = "disk",
[Models.Metadata.Disk.NameKey] = item.Name,
[Models.Metadata.Disk.MD5Key] = item.MD5,
[Models.Metadata.Disk.SHA1Key] = item.SHA1,
@@ -101,6 +98,7 @@ namespace SabreTools.Serialization.CrossModel
{
var rom = new Models.Metadata.Rom
{
[Models.Metadata.DatItem.TypeKey] = "rom",
[Models.Metadata.Rom.NameKey] = item.Name,
[Models.Metadata.Rom.SizeKey] = item.Size,
[Models.Metadata.Rom.CRCKey] = item.CRC,

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class Listxml : IModelSerializer<Mame, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Mame Deserialize(Models.Metadata.MetadataFile obj)
#else
public Mame? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -34,11 +30,7 @@ namespace SabreTools.Serialization.CrossModel
/// <summary>
/// Convert from <cref="Models.Metadata.Models.Metadata.MetadataFile"/> to <cref="Models.Listxml.Mame"/>
/// </summary>
#if NET48
private static Mame ConvertMameFromInternalModel(Models.Metadata.MetadataFile item)
#else
public static Mame? ConvertMameFromInternalModel(Models.Metadata.MetadataFile? item)
#endif
{
if (item == null)
return null;
@@ -316,7 +308,7 @@ namespace SabreTools.Serialization.CrossModel
{
Name = item.ReadString(Models.Metadata.Chip.NameKey),
Tag = item.ReadString(Models.Metadata.Chip.TagKey),
Type = item.ReadString(Models.Metadata.Chip.TypeKey),
Type = item.ReadString(Models.Metadata.Chip.ChipTypeKey),
SoundOnly = item.ReadString(Models.Metadata.Chip.SoundOnlyKey),
Clock = item.ReadString(Models.Metadata.Chip.ClockKey),
};
@@ -415,7 +407,7 @@ namespace SabreTools.Serialization.CrossModel
{
var control = new Control
{
Type = item.ReadString(Models.Metadata.Control.TypeKey),
Type = item.ReadString(Models.Metadata.Control.ControlTypeKey),
Player = item.ReadString(Models.Metadata.Control.PlayerKey),
Buttons = item.ReadString(Models.Metadata.Control.ButtonsKey),
ReqButtons = item.ReadString(Models.Metadata.Control.ReqButtonsKey),
@@ -438,7 +430,7 @@ namespace SabreTools.Serialization.CrossModel
{
var device = new Device
{
Type = item.ReadString(Models.Metadata.Device.TypeKey),
Type = item.ReadString(Models.Metadata.Device.DeviceTypeKey),
Tag = item.ReadString(Models.Metadata.Device.TagKey),
FixedImage = item.ReadString(Models.Metadata.Device.FixedImageKey),
Mandatory = item.ReadString(Models.Metadata.Device.MandatoryKey),
@@ -571,7 +563,7 @@ namespace SabreTools.Serialization.CrossModel
var display = new Display
{
Tag = item.ReadString(Models.Metadata.Display.TagKey),
Type = item.ReadString(Models.Metadata.Display.TypeKey),
Type = item.ReadString(Models.Metadata.Display.DisplayTypeKey),
Rotate = item.ReadString(Models.Metadata.Display.RotateKey),
FlipX = item.ReadString(Models.Metadata.Display.FlipXKey),
Width = item.ReadString(Models.Metadata.Display.WidthKey),
@@ -629,7 +621,7 @@ namespace SabreTools.Serialization.CrossModel
{
var feature = new Feature
{
Type = item.ReadString(Models.Metadata.Feature.TypeKey),
Type = item.ReadString(Models.Metadata.Feature.FeatureTypeKey),
Status = item.ReadString(Models.Metadata.Feature.StatusKey),
Overall = item.ReadString(Models.Metadata.Feature.OverallKey),
};

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class Listxml : IModelSerializer<Mame, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(Mame item)
#else
public Models.Metadata.MetadataFile? Serialize(Mame? item)
#endif
{
if (item == null)
return null;
@@ -268,7 +264,7 @@ namespace SabreTools.Serialization.CrossModel
{
[Models.Metadata.Chip.NameKey] = item.Name,
[Models.Metadata.Chip.TagKey] = item.Tag,
[Models.Metadata.Chip.TypeKey] = item.Type,
[Models.Metadata.Chip.ChipTypeKey] = item.Type,
[Models.Metadata.Chip.SoundOnlyKey] = item.SoundOnly,
[Models.Metadata.Chip.ClockKey] = item.Clock,
};
@@ -363,7 +359,7 @@ namespace SabreTools.Serialization.CrossModel
{
var control = new Models.Metadata.Control
{
[Models.Metadata.Control.TypeKey] = item.Type,
[Models.Metadata.Control.ControlTypeKey] = item.Type,
[Models.Metadata.Control.PlayerKey] = item.Player,
[Models.Metadata.Control.ButtonsKey] = item.Buttons,
[Models.Metadata.Control.ReqButtonsKey] = item.ReqButtons,
@@ -386,7 +382,7 @@ namespace SabreTools.Serialization.CrossModel
{
var device = new Models.Metadata.Device
{
[Models.Metadata.Device.TypeKey] = item.Type,
[Models.Metadata.Device.DeviceTypeKey] = item.Type,
[Models.Metadata.Device.TagKey] = item.Tag,
[Models.Metadata.Device.FixedImageKey] = item.FixedImage,
[Models.Metadata.Device.MandatoryKey] = item.Mandatory,
@@ -513,7 +509,7 @@ namespace SabreTools.Serialization.CrossModel
var display = new Models.Metadata.Display
{
[Models.Metadata.Display.TagKey] = item.Tag,
[Models.Metadata.Display.TypeKey] = item.Type,
[Models.Metadata.Display.DisplayTypeKey] = item.Type,
[Models.Metadata.Display.RotateKey] = item.Rotate,
[Models.Metadata.Display.FlipXKey] = item.FlipX,
[Models.Metadata.Display.WidthKey] = item.Width,
@@ -571,7 +567,7 @@ namespace SabreTools.Serialization.CrossModel
{
var feature = new Models.Metadata.Feature
{
[Models.Metadata.Feature.TypeKey] = item.Type,
[Models.Metadata.Feature.FeatureTypeKey] = item.Type,
[Models.Metadata.Feature.StatusKey] = item.Status,
[Models.Metadata.Feature.OverallKey] = item.Overall,
};

View File

@@ -7,18 +7,10 @@ namespace SabreTools.Serialization.CrossModel
public partial class Logiqx : IModelSerializer<Datafile, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Datafile Deserialize(Models.Metadata.MetadataFile obj) => Deserialize(obj, false);
#else
public Datafile? Deserialize(Models.Metadata.MetadataFile? obj) => Deserialize(obj, false);
#endif
/// <inheritdoc/>
#if NET48
public Datafile Deserialize(Models.Metadata.MetadataFile obj, bool game)
#else
public Datafile? Deserialize(Models.Metadata.MetadataFile? obj, bool game)
#endif
{
if (obj == null)
return null;
@@ -111,15 +103,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static GameBase ConvertMachineFromInternalModel(Models.Metadata.Machine item, bool game = false)
{
#if NET48
GameBase gameBase;
if (game)
gameBase = new Game();
else
gameBase = new Machine();
#else
GameBase gameBase = game ? new Game() : new Machine();
#endif
gameBase.Name = item.ReadString(Models.Metadata.Machine.NameKey);
gameBase.SourceFile = item.ReadString(Models.Metadata.Machine.SourceFileKey);

View File

@@ -8,11 +8,7 @@ namespace SabreTools.Serialization.CrossModel
{
public partial class Logiqx : IModelSerializer<Datafile, Models.Metadata.MetadataFile>
{
#if NET48
public Models.Metadata.MetadataFile Serialize(Datafile item)
#else
public Models.Metadata.MetadataFile? Serialize(Datafile? item)
#endif
{
if (item == null)
return null;
@@ -26,9 +22,9 @@ namespace SabreTools.Serialization.CrossModel
if (item.Game != null && item.Game.Any())
{
machines.AddRange(item.Game
.Where(g => g != null)
.Select(ConvertMachineToInternalModel));
machines.AddRange(item.Game
.Where(g => g != null)
.Select(ConvertMachineToInternalModel));
}
if (item.Dir != null && item.Dir.Any())
@@ -108,7 +104,7 @@ namespace SabreTools.Serialization.CrossModel
private static Models.Metadata.Machine[] ConvertDirToInternalModel(Dir item)
{
if (item.Game == null || !item.Game.Any())
return Array.Empty<Models.Metadata.Machine>();
return [];
return item.Game
.Where(g => g != null)

View File

@@ -6,11 +6,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class M1 : IModelSerializer<Models.Listxml.M1, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Listxml.M1 Deserialize(Models.Metadata.MetadataFile obj)
#else
public Models.Listxml.M1? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -6,11 +6,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class M1 : IModelSerializer<Models.Listxml.M1, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(Models.Listxml.M1 item)
#else
public Models.Metadata.MetadataFile? Serialize(Models.Listxml.M1? item)
#endif
{
if (item == null)
return null;

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class OfflineList : IModelSerializer<Dat, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Dat Deserialize(Models.Metadata.MetadataFile obj)
#else
public Dat? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class OfflineList : IModelSerializer<Dat, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public Models.Metadata.MetadataFile Serialize(Dat item)
#else
public Models.Metadata.MetadataFile? Serialize(Dat? item)
#endif
{
if (item == null)
return null;

View File

@@ -7,11 +7,7 @@ namespace SabreTools.Serialization.CrossModel
public partial class OpenMSX : IModelSerializer<SoftwareDb, Models.Metadata.MetadataFile>
{
/// <inheritdoc/>
#if NET48
public SoftwareDb Deserialize(Models.Metadata.MetadataFile obj)
#else
public SoftwareDb? Deserialize(Models.Metadata.MetadataFile? obj)
#endif
{
if (obj == null)
return null;
@@ -104,7 +100,7 @@ namespace SabreTools.Serialization.CrossModel
var megaRom = new MegaRom
{
Start = item.ReadString(Models.Metadata.Rom.StartKey),
Type = item.ReadString(Models.Metadata.Rom.TypeKey),
Type = item.ReadString(Models.Metadata.Rom.OpenMSXType),
Hash = item.ReadString(Models.Metadata.Rom.SHA1Key),
Remark = item.ReadString(Models.Metadata.Rom.RemarkKey),
};
@@ -132,7 +128,7 @@ namespace SabreTools.Serialization.CrossModel
var rom = new Rom
{
Start = item.ReadString(Models.Metadata.Rom.StartKey),
Type = item.ReadString(Models.Metadata.Rom.TypeKey),
Type = item.ReadString(Models.Metadata.Rom.OpenMSXType),
Hash = item.ReadString(Models.Metadata.Rom.SHA1Key),
Remark = item.ReadString(Models.Metadata.Rom.RemarkKey),
};
@@ -147,7 +143,7 @@ namespace SabreTools.Serialization.CrossModel
var sccPlusCart = new SCCPlusCart
{
Start = item.ReadString(Models.Metadata.Rom.StartKey),
Type = item.ReadString(Models.Metadata.Rom.TypeKey),
Type = item.ReadString(Models.Metadata.Rom.OpenMSXType),
Hash = item.ReadString(Models.Metadata.Rom.SHA1Key),
Remark = item.ReadString(Models.Metadata.Rom.RemarkKey),
};

Some files were not shown because too many files have changed in this diff Show More