#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 bool2 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { throw new InvalidOperationException("typecode is null, struct not supported"); } var length = reader.ReadArrayHeader(); var x = default(bool); var y = default(bool); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: x = reader.ReadBoolean(); break; case 1: y = reader.ReadBoolean(); break; default: reader.Skip(); break; } } var result = bool2(x, y); return(result); }
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); }
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)); }
protected override PackageSourceContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { string?source = null; string?name = null; bool isMachineWide = false; bool isEnabled = true; string?description = null; int originalHashCode = 0; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case SourcePropertyName: source = reader.ReadString(); break; case IsEnabledPropertyName: isEnabled = reader.ReadBoolean(); break; case IsMachineWidePropertyName: isMachineWide = reader.ReadBoolean(); break; case NamePropertyName: name = reader.ReadString(); break; case DescriptionPropertyName: description = reader.ReadString(); break; case OriginalHashCodePropertyName: originalHashCode = reader.ReadInt32(); break; default: reader.Skip(); break; } } Assumes.NotNullOrEmpty(source); Assumes.NotNullOrEmpty(name); return(new PackageSourceContextInfo(source, name, isEnabled) { IsMachineWide = isMachineWide, Description = description, OriginalHashCode = originalHashCode, }); }
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--; } }
protected override SearchFilter?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { bool includePrerelease = false; bool includeDelisted = false; SearchFilterType? filterType = null; SearchOrderBy? searchOrderBy = null; IEnumerable <string>?supportedFrameworks = null; IEnumerable <string>?packageTypes = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case IncludePrereleasePropertyName: includePrerelease = reader.ReadBoolean(); break; case IncludeDelistedPropertyName: includeDelisted = reader.ReadBoolean(); break; case PackageTypesPropertyName: packageTypes = options.Resolver.GetFormatter <IEnumerable <string> >().Deserialize(ref reader, options); break; case FilterPropertyName: filterType = options.Resolver.GetFormatter <SearchFilterType?>().Deserialize(ref reader, options); break; case OrderByPropertyName: searchOrderBy = options.Resolver.GetFormatter <SearchOrderBy?>().Deserialize(ref reader, options); break; case SupportedFrameworksPropertyName: supportedFrameworks = options.Resolver.GetFormatter <IEnumerable <string> >().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } return(new SearchFilter(includePrerelease, filterType) { SupportedFrameworks = supportedFrameworks, OrderBy = searchOrderBy, PackageTypes = packageTypes, IncludeDelisted = includeDelisted, }); }
public Polygon Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { reader.ReadArrayHeader(); var hole = reader.ReadBoolean(); var nx = reader.ReadArrayHeader(); var x = new double[nx]; for (var j = 0; j < nx; j++) { x[j] = reader.ReadDouble(); } var ny = reader.ReadArrayHeader(); var y = new double[ny]; for (var j = 0; j < ny; j++) { y[j] = reader.ReadDouble(); } return(new Polygon { Hole = hole, Longitude = x, Latitude = y }); }
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field) { try { if (type == typeof(string)) { return(ReadString(ref reader, "argument")); } else if (type == typeof(bool)) { return(reader.ReadBoolean()); } else if (type == typeof(int)) { return(reader.ReadInt32()); } else if (type == typeof(long)) { return(reader.ReadInt64()); } else if (type == typeof(float)) { return(reader.ReadSingle()); } } catch (Exception ex) { throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex); } throw new FormatException($"Type {type} is not supported"); }
public Result<T,TE> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) return default; var count = reader.ReadArrayHeader(); if (count != HeaderCount) throw new InvalidOperationException(); if (!reader.ReadBoolean()) { reader.ReadNil(); var formatter = options.Resolver.GetFormatterWithVerify<T>(); var value = formatter.Deserialize(ref reader, options); return Result.Success<T,TE>(value); } else { var formatter = options.Resolver.GetFormatterWithVerify<TE>(); var error = formatter.Deserialize(ref reader, options); return Result.Failure<T,TE>(error); } }
static Task PublishFromRedisToMemoryGroup(RedisValue value, IGroup group) { byte[] buffer = value; var reader = new MessagePackReader(buffer); var len1 = reader.ReadArrayHeader(); if (len1 == 3) { var isExcept = reader.ReadBoolean(); if (isExcept) { var excludes = NativeGuidArrayFormatter.Deserialize(ref reader); var offset = (int)reader.Consumed; return(group.WriteExceptRawAsync(new ArraySegment <byte>(buffer, offset, buffer.Length - offset), excludes, fireAndForget: false)); } else { var includes = NativeGuidArrayFormatter.Deserialize(ref reader); var offset = (int)reader.Consumed; return(group.WriteToRawAsync(new ArraySegment <byte>(buffer, offset, buffer.Length - offset), includes, fireAndForget: false)); } } return(Task.CompletedTask); }
public Boolean?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } return(reader.ReadBoolean()); }
public PackageSourceUpdateOptions?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) #pragma warning restore CS0618 // Type or member is obsolete { 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 { 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 } finally { // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf reader.Depth--; } }
private static bool ReadBoolean(ref MessagePackReader reader, string field) { if (reader.End || reader.NextMessagePackType != MessagePackType.Boolean) { ThrowInvalidDataException(field, "Boolean"); } return(reader.ReadBoolean()); }
public override Target Deserialize(ref MessagePackReader reader) { var value = new Target(); value.BoolValue = reader.ReadBoolean(); value.IntValue = reader.ReadInt32(); return(value); }
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; }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); int count = reader.ReadArrayHeader(); for (int i = 0; i < count; i++) { int key = reader.ReadInt32(); 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; } } } return(value); } return(default);
private static bool ReadBoolean(ref MessagePackReader reader, string field) { try { return(reader.ReadBoolean()); } catch (Exception ex) { throw new InvalidDataException($"Reading '{field}' as Boolean failed.", ex); } }
public object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options) { switch (id) { case MASS_ID: return(reader.ReadSingle()); case DRAG_ID: return(reader.ReadSingle()); case ANGULAR_DRAG_ID: return(reader.ReadSingle()); case USE_GRAVITY_ID: return(reader.ReadBoolean()); case IS_KINEMATIC_ID: return(reader.ReadBoolean()); } return(default);
public void Print() { var reader = new MessagePackReader(new byte[] { 195, 10 }); reader.ReadBoolean(); reader.ReadInt32(); string actual = reader.Print(); string expected = "[195, 10]"; Assert.AreEqual(expected, actual); }
public static bool?ReadNullableBool(ref MessagePackReader reader) { if (!reader.IsNil) { return(reader.ReadBoolean()); } else { reader.ReadNil(); return(null); } }
protected override PackageSource?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { 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 }); }
public global::GatewayServer.Packet.PKTNTFGameInfo 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.ReadArrayHeader(); var __Result__ = default(ushort); var __OpponentID__ = default(string); var __IsBlack__ = default(bool); var __OpponentGameRecord__ = default((ushort, ushort)); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Result__ = reader.ReadUInt16(); break; case 1: __OpponentID__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 2: __IsBlack__ = reader.ReadBoolean(); break; case 3: __OpponentGameRecord__ = formatterResolver.GetFormatterWithVerify <(ushort, ushort)>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::GatewayServer.Packet.PKTNTFGameInfo(); ____result.Result = __Result__; ____result.OpponentID = __OpponentID__; ____result.IsBlack = __IsBlack__; ____result.OpponentGameRecord = __OpponentGameRecord__; reader.Depth--; return(____result); }
public T[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { return(null); } var ext = reader.ReadExtensionFormat(); if (ext.Header.TypeCode != TypeCode) { throw new InvalidOperationException("Invalid typeCode."); } var extReader = new MessagePackReader(ext.Data); var isLittleEndian = extReader.ReadBoolean(); // extReader.read byte[] rentMemory = default; ReadOnlySpan <byte> span = default; { var seqSlice = extReader.Sequence.Slice(extReader.Position); if (isLittleEndian != BitConverter.IsLittleEndian) { rentMemory = ArrayPool <byte> .Shared.Rent((int)seqSlice.Length); seqSlice.CopyTo(rentMemory); Array.Reverse(rentMemory); span = rentMemory; } else { if (seqSlice.IsSingleSegment) { span = seqSlice.First.Span; } else { rentMemory = ArrayPool <byte> .Shared.Rent((int)seqSlice.Length); seqSlice.CopyTo(rentMemory); span = rentMemory; } } } var result = new T[span.Length / StructLength]; Unsafe.CopyBlockUnaligned(ref Unsafe.As <T, byte>(ref result[0]), ref MemoryMarshal.GetReference(span), (uint)span.Length); return(result); }
public MessageHeader Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { string userName = reader.ReadString(); string messageId = reader.ReadString(); long createTime = reader.ReadInt64(); long requestTime = reader.ReadInt64(); bool isFragmented = reader.ReadBoolean(); bool? firstFragment = MsgPackUtils.ReadNullableBool(ref reader); bool? lastFragment = MsgPackUtils.ReadNullableBool(ref reader); int? offset = MsgPackUtils.ReadNullableInt(ref reader); int? fullDataSize = MsgPackUtils.ReadNullableInt(ref reader); int dataType = reader.ReadInt32(); return(new MessageHeader(userName, messageId, createTime, requestTime, isFragmented, firstFragment, lastFragment, offset, fullDataSize, (DataType)dataType)); }
public override TestTarget Deserialize(ref MessagePackReader reader) { if (!reader.TryReadNil()) { var value = new TestTarget(); value.BoolValue = reader.ReadBoolean(); value.IntValue = reader.ReadInt32(); value.FloatValue = reader.ReadSingle(); value.StringValue = reader.ReadString(); value.EnumValue = m_formatterTypeCode.Deserialize(ref reader); return(value); } return(default);
public BitArray Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } var len = reader.ReadArrayHeader(); var array = new BitArray(len); for (int i = 0; i < len; i++) { array[i] = reader.ReadBoolean(); } return(array); }
protected override SearchResultContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { Guid?operationId = null; bool hasMoreItems = false; IReadOnlyCollection <PackageSearchMetadataContextInfo>?packageSearchItems = null; IReadOnlyDictionary <string, LoadingStatus>? sourceLoadingStatus = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case HasMoreItemsPropertyName: hasMoreItems = reader.ReadBoolean(); break; case PackageSearchItemsPropertyName: packageSearchItems = options.Resolver.GetFormatter <IReadOnlyCollection <PackageSearchMetadataContextInfo> >().Deserialize(ref reader, options); break; case SourceLoadingStatusPropertyName: sourceLoadingStatus = options.Resolver.GetFormatter <IReadOnlyDictionary <string, LoadingStatus> >().Deserialize(ref reader, options); break; case OperationIdPropertyName: if (!reader.TryReadNil()) { string guidString = reader.ReadString(); if (Guid.TryParse(guidString, out Guid operationIdGuid)) { operationId = operationIdGuid; } } break; default: reader.Skip(); break; } } Assumes.NotNull(packageSearchItems); Assumes.NotNull(sourceLoadingStatus); return(new SearchResultContextInfo(packageSearchItems, sourceLoadingStatus, hasMoreItems, operationId)); }
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field) { try { if (type == typeof(string)) { return(ReadString(ref reader, "argument")); } else if (type == typeof(bool)) { return(reader.ReadBoolean()); } else if (type == typeof(int)) { return(reader.ReadInt32()); } else if (type == typeof(long)) { return(reader.ReadInt64()); } else if (type == typeof(float)) { return(reader.ReadSingle()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); if (!bytes.HasValue) { return(null); } else if (bytes.Value.Length == 0) { return(Array.Empty <byte>()); } return(bytes.Value.ToArray()); } } catch (Exception ex) { throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex); } throw new FormatException($"Type {type} is not supported"); }