public global::TestData2.Nest2.IdType Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadMapHeader(); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { default: reader.Skip(); break; } } var ____result = new global::TestData2.Nest2.IdType(); reader.Depth--; return(____result); }
protected override IProjectContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { NuGetProjectKind projectKind = NuGetProjectKind.Unknown; ProjectStyle projectStyle = ProjectStyle.Unknown; string? projectId = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case ProjectIdPropertyName: projectId = reader.ReadString(); break; case ProjectKindPropertyName: projectKind = options.Resolver.GetFormatter <NuGetProjectKind>().Deserialize(ref reader, options); break; case ProjectStylePropertyName: projectStyle = options.Resolver.GetFormatter <ProjectStyle>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } Assumes.NotNull(projectId); return(new ProjectContextInfo(projectId, projectStyle, projectKind)); }
protected override PackageDependencyGroup?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { NuGetFramework?framework = null; IEnumerable <PackageDependency>?packageDependencies = null; int propertyCount = reader.ReadMapHeader(); for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex) { switch (reader.ReadString()) { case TargetFrameworkPropertyName: framework = NuGetFrameworkFormatter.Instance.Deserialize(ref reader, options); break; case PackagesPropertyName: packageDependencies = options.Resolver.GetFormatter <IEnumerable <PackageDependency> >().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } Assumes.NotNull(framework); Assumes.NotNull(packageDependencies); return(new PackageDependencyGroup(framework, packageDependencies)); }
protected override PackageVulnerabilityMetadataContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { Uri?advisoryUrl = null; int severity = 0; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case AdvisoryUrlPropertyName: advisoryUrl = options.Resolver.GetFormatter <Uri>().Deserialize(ref reader, options); break; case SeverityPropertyName: severity = reader.ReadInt32(); break; default: reader.Skip(); break; } } Assumes.NotNull(advisoryUrl); return(new PackageVulnerabilityMetadataContextInfo(advisoryUrl, severity)); }
#pragma warning disable CS0618 // Type or member is obsolete protected override PackageSourceUpdateOptions?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) #pragma warning restore CS0618 // Type or member is obsolete { bool updateCredentials = true; bool updateEnabled = true; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case UpdateCredentialsPropertyName: updateCredentials = reader.ReadBoolean(); break; case UpdateEnabledPropertyName: updateEnabled = reader.ReadBoolean(); break; default: reader.Skip(); break; } } #pragma warning disable CS0618 // Type or member is obsolete return(new PackageSourceUpdateOptions(updateCredentials, updateEnabled)); #pragma warning restore CS0618 // Type or member is obsolete }
public TDictionary Deserialize(ref MessagePackReader reader, IFormatterResolver resolver) { if (reader.TryReadNil()) { return(default(TDictionary)); } else { var keyFormatter = resolver.GetFormatterWithVerify <TKey>(); var valueFormatter = resolver.GetFormatterWithVerify <TValue>(); var len = reader.ReadMapHeader(); var dict = Create(len); for (int i = 0; i < len; i++) { var key = keyFormatter.Deserialize(ref reader, resolver); var value = valueFormatter.Deserialize(ref reader, resolver); Add(dict, i, key, value); } return(Complete(dict)); } }
protected override PackageDeprecationMetadataContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string?message = null; IReadOnlyCollection <string>? reasons = null; AlternatePackageMetadataContextInfo?alternatePackageMetadataContextInfo = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case MessagePropertyName: message = reader.ReadString(); break; case ReasonsPropertyName: reasons = reader.TryReadNil() ? null : options.Resolver.GetFormatter <IReadOnlyCollection <string> >().Deserialize(ref reader, options); break; case AlternatePackageMetadataPropertyName: alternatePackageMetadataContextInfo = reader.TryReadNil() ? null : AlternatePackageMetadataContextInfoFormatter.Instance.Deserialize(ref reader, options); break; default: reader.Skip(); break; } } Assumes.NotNullOrEmpty(message); return(new PackageDeprecationMetadataContextInfo(message, reasons, alternatePackageMetadataContextInfo)); }
protected override FloatRange?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { NuGetVersionFloatBehavior?floatBehavior = null; NuGetVersion?minVersion = null; string? releasePrefix = null; int propertyCount = reader.ReadMapHeader(); for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex) { switch (reader.ReadString()) { case FloatBehaviorPropertyName: floatBehavior = options.Resolver.GetFormatter <NuGetVersionFloatBehavior>().Deserialize(ref reader, options); break; case MinVersionPropertyName: minVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options); break; case ReleasePrefixPropertyName: releasePrefix = reader.ReadString(); break; default: reader.Skip(); break; } } Assumes.True(floatBehavior.HasValue); return(new FloatRange(floatBehavior.Value, minVersion, releasePrefix)); }
internal void ReadExtensionMembers(ref MessagePackReader reader) { int count = reader.ReadMapHeader(); for (int i = 0; i < count; i++) { switch (reader.ReadInt32()) { case TracingId: if (this is IMessageWithTracingId withTracingId) { withTracingId.TracingId = reader.ReadUInt64(); } break; case Ttl: if (this is IHasTtl hasTtl) { hasTtl.Ttl = reader.ReadInt32(); } break; case Protocol: if (this is IHasProtocol hasProtocol) { hasProtocol.Protocol = reader.ReadString(); } break; // todo : more optional fields default: break; } } }
public TDictionary Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(default(TDictionary)); } else { IFormatterResolver resolver = options.Resolver; IMessagePackFormatter <TKey> keyFormatter = resolver.GetFormatterWithVerify <TKey>(); IMessagePackFormatter <TValue> valueFormatter = resolver.GetFormatterWithVerify <TValue>(); var len = reader.ReadMapHeader(); TIntermediate dict = this.Create(len, options); for (int i = 0; i < len; i++) { reader.CancellationToken.ThrowIfCancellationRequested(); TKey key = keyFormatter.Deserialize(ref reader, options); TValue value = valueFormatter.Deserialize(ref reader, options); this.Add(dict, i, key, value, options); } return(this.Complete(dict)); } }
private static void DeserializeFormat0(ref MessagePackReader reader, MessagePackSerializerOptions options, ref string message, ref int number) { int length = reader.ReadMapHeader(); int i = 0; IFormatterResolver resolver = options.Resolver; while (i < length) { ReadOnlySpan <byte> stringKey = CodeGenHelpers.ReadStringSpan(ref reader); int length2 = stringKey.Length; ulong key = 0uL; if (length2 <= 8) { key = AutomataKeyGen.GetKey(ref stringKey); } if (length2 == 7 && key == 28542640894207341L) { message = reader.ReadString(); } else if (length2 == 6 && key == 125779768604014L) { number = reader.ReadInt32(); } else { reader.Skip(); } i++; } }
public ArgumentDictionary Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } ArgumentDictionary arguments = new ArgumentDictionary(); var len = reader.ReadMapHeader(); options.Security.DepthStep(ref reader); try { for (int i = 0; i < len; i++) { string argumentName = reader.ReadString(); Type argumentType = argumentMapping[argumentName]; object value = Deserialize(argumentType, ref reader, options); arguments.Add(argumentName, value); } } finally { reader.Depth--; } return(arguments); }
public void MapHeaderTest(uint target, int length) { (MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker(); var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); writer.WriteMapHeader(target); writer.Flush(); sequence.Length.Is(length); packer.PackMapHeader((int)target).Position.Is(sequence.Length); stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue(); // Expand sequence enough that ReadArrayHeader doesn't throw due to its security check. writer.Write(new byte[target * 2]); writer.Flush(); var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence); sequenceReader.ReadMapHeader().Is((int)target); sequenceReader.ReadBytes(); // read the padding we added sequenceReader.End.IsTrue(); var ms = new MemoryStream(sequence.AsReadOnlySequence.ToArray()); var unpacker = MsgPack.Unpacker.Create(ms); long len; unpacker.ReadMapLength(out len).IsTrue(); len.Is(target); }
protected override PackageIdentity?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string? id = null; NuGetVersion?version = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case IdPropertyName: id = reader.ReadString(); break; case NuGetVersionPropertyName: version = NuGetVersionFormatter.Instance.Deserialize(ref reader, options); break; default: reader.Skip(); break; } } return(new PackageIdentity(id, version)); }
protected override AlternatePackageMetadataContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string? packageId = null; VersionRange?range = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case PackageIdPropertyName: packageId = reader.ReadString(); break; case VersionRangePropertyName: range = VersionRangeFormatter.Instance.Deserialize(ref reader, options); break; default: reader.Skip(); break; } } Assumes.NotNullOrEmpty(packageId); Assumes.NotNull(range); return(new AlternatePackageMetadataContextInfo(packageId, range)); }
public ExpandoObject Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } var result = new ExpandoObject(); int count = reader.ReadMapHeader(); if (count > 0) { IFormatterResolver resolver = options.Resolver; IMessagePackFormatter <string> keyFormatter = resolver.GetFormatterWithVerify <string>(); IMessagePackFormatter <object> valueFormatter = resolver.GetFormatterWithVerify <object>(); IDictionary <string, object> dictionary = result; options.Security.DepthStep(ref reader); try { for (int i = 0; i < count; i++) { string key = keyFormatter.Deserialize(ref reader, options); object value = valueFormatter.Deserialize(ref reader, options); dictionary.Add(key, value); } } finally { reader.Depth--; } } return(result); }
protected override NuGetFramework?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string?frameworkName = null; string?platformName = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case DotNetFrameworkNamePropertyName: frameworkName = reader.ReadString(); break; case DotNetPlatformNamePropertyName: platformName = reader.ReadString(); break; default: reader.Skip(); break; } } return(NuGetFramework.ParseComponents(frameworkName, platformName)); }
public global::DM.MessagePackTest Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadMapHeader(); var __IsNetworkError__ = default(bool); var __IsHttpError__ = default(bool); var __ResponseCode__ = default(int); var __Sec__ = default(int); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __IsNetworkError__ = reader.ReadBoolean(); break; case 1: __IsHttpError__ = reader.ReadBoolean(); break; case 2: __ResponseCode__ = reader.ReadInt32(); break; case 3: __Sec__ = reader.ReadInt32(); break; default: reader.Skip(); break; } } var ____result = new global::DM.MessagePackTest(); ____result.IsNetworkError = __IsNetworkError__; ____result.IsHttpError = __IsHttpError__; ____result.ResponseCode = __ResponseCode__; ____result.Sec = __Sec__; reader.Depth--; return(____result); }
public global::DM.Person Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadMapHeader(); var __PersonId__ = default(int); var __Age__ = default(int); var __Gender__ = default(global::DM.Gender); var __Name__ = default(string); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __PersonId__ = reader.ReadInt32(); break; case 1: __Age__ = reader.ReadInt32(); break; case 2: __Gender__ = formatterResolver.GetFormatterWithVerify <global::DM.Gender>().Deserialize(ref reader, options); break; case 3: __Name__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::DM.Person(); ____result.PersonId = __PersonId__; ____result.Age = __Age__; ____result.Gender = __Gender__; ____result.Name = __Name__; reader.Depth--; return(____result); }
public EventDocumentAckResult Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { reader.ReadArrayHeader(); StatusCode status = (StatusCode)reader.ReadInt32(); string notification = reader.ReadString(); reader.ReadMapHeader(); return(new EventDocumentAckResult(status, notification)); }
private static int ReadMapHeader(ref MessagePackReader reader, string field) { if (reader.End || reader.NextMessagePackType != MessagePackType.Map) { ThrowInvalidCollectionLengthException(field, "map"); } return(reader.ReadMapHeader()); }
protected override ProjectAction? DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string? id = null; ImplicitProjectAction[]? implicitActions = null; PackageIdentity? packageIdentity = null; NuGetProjectActionType? projectActionType = null; string? projectId = null; int propertyCount = reader.ReadMapHeader(); for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex) { switch (reader.ReadString()) { case IdPropertyName: id = reader.ReadString(); break; case ImplicitActionsPropertyName: int elementCount = reader.ReadArrayHeader(); implicitActions = new ImplicitProjectAction[elementCount]; for (var i = 0; i < elementCount; ++i) { ImplicitProjectAction? implicitAction = ImplicitProjectActionFormatter.Instance.Deserialize(ref reader, options); Assumes.NotNull(implicitAction); implicitActions[i] = implicitAction; } break; case PackageIdentityPropertyName: packageIdentity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options); break; case ProjectActionTypePropertyName: projectActionType = options.Resolver.GetFormatter<NuGetProjectActionType>().Deserialize(ref reader, options); break; case ProjectIdPropertyName: projectId = reader.ReadString(); break; default: reader.Skip(); break; } } Assumes.NotNullOrEmpty(id); Assumes.NotNull(packageIdentity); Assumes.True(projectActionType.HasValue); Assumes.NotNullOrEmpty(projectId); return new ProjectAction(id, projectId, packageIdentity, projectActionType.Value, implicitActions); }
public global::MasterMemory.Tests.Sample Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadMapHeader(); var __Id__ = default(int); var __Age__ = default(int); var __FirstName__ = default(string); var __LastName__ = default(string); for (int i = 0; i < length; i++) { ReadOnlySpan <byte> stringKey = Internal.CodeGenHelpers.ReadStringSpan(ref reader); int key; if (!this.____keyMapping.TryGetValue(stringKey, out key)) { reader.Skip(); continue; } switch (key) { case 0: __Id__ = reader.ReadInt32(); break; case 1: __Age__ = reader.ReadInt32(); break; case 2: __FirstName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 3: __LastName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::MasterMemory.Tests.Sample(__Id__, __Age__, __FirstName__, __LastName__); ____result.Id = __Id__; ____result.Age = __Age__; ____result.FirstName = __FirstName__; ____result.LastName = __LastName__; return(____result); }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); int count = reader.ReadMapHeader(); for (int i = 0; i < count; i++) { ArraySegment<byte> segment = reader.ReadStringSegment(); if (m_nameToKey.TryGetValue(segment.Array, segment.Offset, segment.Count, out int key)) { switch (key) { case 0: { value.BoolValue = reader.ReadBoolean(); break; } case 1: { value.IntValue = reader.ReadInt32(); break; } case 2: { value.FloatValue = reader.ReadSingle(); break; } case 3: { value.StringValue = reader.ReadString(); break; } case 4: { value.EnumValue = m_formatterTypeCode.Deserialize(ref reader); break; } default: { reader.ReadNextBlock(); break; } } } else { reader.ReadNextBlock(); } } } return default; }
protected override VersionRange?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { FloatRange? floatRange = null; bool? isMaxInclusive = null; bool? isMinInclusive = null; NuGetVersion?maxVersion = null; NuGetVersion?minVersion = null; string? originalString = null; int propertyCount = reader.ReadMapHeader(); for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex) { switch (reader.ReadString()) { case FloatRangePropertyName: floatRange = FloatRangeFormatter.Instance.Deserialize(ref reader, options); break; case IsMaxInclusivePropertyName: isMaxInclusive = reader.ReadBoolean(); break; case IsMinInclusivePropertyName: isMinInclusive = reader.ReadBoolean(); break; case MaxVersionPropertyName: maxVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options); break; case MinVersionPropertyName: minVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options); break; case OriginalStringPropertyName: originalString = reader.ReadString(); break; default: reader.Skip(); break; } } Assumes.True(isMinInclusive.HasValue); Assumes.True(isMaxInclusive.HasValue); return(new VersionRange( minVersion, isMinInclusive.Value, maxVersion, isMaxInclusive.Value, floatRange, originalString)); }
protected override PackageReference?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { VersionRange? allowedVersions = null; bool isDevelopmentDependency = false; bool isUserInstalled = true; bool requireReinstallation = false; PackageIdentity?identity = null; NuGetFramework? framework = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case AllowedVersionsPropertyName: allowedVersions = VersionRangeFormatter.Instance.Deserialize(ref reader, options); break; case IsDevelopmentDependencyPropertyName: isDevelopmentDependency = reader.ReadBoolean(); break; case IsUserInstalledPropertyName: isUserInstalled = reader.ReadBoolean(); break; case PackageIdentityPropertyName: identity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options); break; case RequireReinstallationPropertyName: requireReinstallation = reader.ReadBoolean(); break; case TargetFrameworkPropertyName: framework = NuGetFrameworkFormatter.Instance.Deserialize(ref reader, options); break; default: reader.Skip(); break; } } Assumes.NotNull(identity); Assumes.NotNull(framework); return(new PackageReference( identity, framework, isUserInstalled, isDevelopmentDependency, requireReinstallation, allowedVersions)); }
public PackageDependencyInfo?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf options.Security.DepthStep(ref reader); try { PackageIdentity? packageIdentity = null; List <PackageDependency>?packageDependencies = null; int propertyCount = reader.ReadMapHeader(); for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex) { switch (reader.ReadString()) { case PackageIdentityPropertyName: packageIdentity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options); break; case PackageDependenciesPropertyName: packageDependencies = new List <PackageDependency>(); int dependenciesCount = reader.ReadArrayHeader(); for (var i = 0; i < dependenciesCount; ++i) { PackageDependency?packageDependency = PackageDependencyFormatter.Instance.Deserialize(ref reader, options); Assumes.NotNull(packageDependency); packageDependencies.Add(packageDependency); } break; default: reader.Skip(); break; } } Assumes.NotNull(packageIdentity); return(new PackageDependencyInfo(packageIdentity, packageDependencies)); } finally { // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf reader.Depth--; } }
protected override LicenseMetadata?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { LicenseType type = LicenseType.File; string? license = null; NuGetLicenseExpression?licenseExpression = null; IReadOnlyList <string>?warningsAndErrors = null; Version? version = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case TypePropertyName: if (!reader.TryReadNil()) { type = options.Resolver.GetFormatter <LicenseType>().Deserialize(ref reader, options); } break; case LicensePropertyName: license = reader.ReadString(); break; case LicenseExpressionPropertyName: var expressionString = reader.ReadString(); if (expressionString != null) { licenseExpression = NuGetLicenseExpression.Parse(expressionString); } break; case WarningsAndErrorsPropertyName: if (!reader.TryReadNil()) { warningsAndErrors = options.Resolver.GetFormatter <IReadOnlyList <string> >().Deserialize(ref reader, options); } break; case VersionPropertyName: version = options.Resolver.GetFormatter <Version>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } return(new LicenseMetadata(type, license, licenseExpression, warningsAndErrors, version)); }
public void Read(ref MessagePackReader reader, ref byte position) { var length = reader.ReadMapHeader(); for (int i = 0; i < length; i++) { reader.ReadNext(); // key reader.ReadNext(); // value } }
public PackageSource?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf options.Security.DepthStep(ref reader); try { string?name = null; string?source = null; bool isEnabled = false; bool isMachineWide = false; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case NamePropertyName: name = reader.ReadString(); break; case SourcePropertyName: source = reader.ReadString(); break; case IsEnabledPropertyName: isEnabled = reader.ReadBoolean(); break; case IsMachineWidePropertyName: isMachineWide = reader.ReadBoolean(); break; default: reader.Skip(); break; } } return(new PackageSource(source, name, isEnabled) { IsMachineWide = isMachineWide }); } finally { // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf reader.Depth--; } }