#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");
}