From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/ProtoBuf/BclHelpers.cs | 659 ++++++ .../XMainClient/ProtoBuf/BclHelpers.cs.meta | 12 + .../XMainClient/ProtoBuf/BufferExtension.cs | 72 + .../XMainClient/ProtoBuf/BufferExtension.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/BufferPool.cs | 87 + .../XMainClient/ProtoBuf/BufferPool.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/DataFormat.cs | 13 + .../XMainClient/ProtoBuf/DataFormat.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Extensible.cs | 108 + .../XMainClient/ProtoBuf/Extensible.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs | 109 + .../XMainClient/ProtoBuf/ExtensibleUtil.cs.meta | 12 + .../Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs | 341 +++ .../Scripts/XMainClient/ProtoBuf/Helpers.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/IExtensible.cs | 9 + .../XMainClient/ProtoBuf/IExtensible.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/IExtension.cs | 18 + .../XMainClient/ProtoBuf/IExtension.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ImplicitFields.cs | 11 + .../XMainClient/ProtoBuf/ImplicitFields.cs.meta | 12 + .../ProtoBuf/MemberSerializationOptions.cs | 16 + .../ProtoBuf/MemberSerializationOptions.cs.meta | 12 + .../Assets/Scripts/XMainClient/ProtoBuf/Meta.meta | 9 + .../XMainClient/ProtoBuf/Meta/AttributeMap.cs | 117 + .../XMainClient/ProtoBuf/Meta/AttributeMap.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs | 337 +++ .../XMainClient/ProtoBuf/Meta/BasicList.cs.meta | 12 + .../XMainClient/ProtoBuf/Meta/CallbackSet.cs | 160 ++ .../XMainClient/ProtoBuf/Meta/CallbackSet.cs.meta | 12 + .../ProtoBuf/Meta/LockContentedEventArgs.cs | 22 + .../ProtoBuf/Meta/LockContentedEventArgs.cs.meta | 12 + .../ProtoBuf/Meta/LockContentedEventHandler.cs | 6 + .../Meta/LockContentedEventHandler.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs | 2327 ++++++++++++++++++++ .../XMainClient/ProtoBuf/Meta/MetaType.cs.meta | 12 + .../XMainClient/ProtoBuf/Meta/MutableList.cs | 29 + .../XMainClient/ProtoBuf/Meta/MutableList.cs.meta | 12 + .../XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs | 1160 ++++++++++ .../ProtoBuf/Meta/RuntimeTypeModel.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Meta/SubType.cs | 117 + .../XMainClient/ProtoBuf/Meta/SubType.cs.meta | 12 + .../ProtoBuf/Meta/TypeFormatEventArgs.cs | 76 + .../ProtoBuf/Meta/TypeFormatEventArgs.cs.meta | 12 + .../ProtoBuf/Meta/TypeFormatEventHandler.cs | 6 + .../ProtoBuf/Meta/TypeFormatEventHandler.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs | 1511 +++++++++++++ .../XMainClient/ProtoBuf/Meta/TypeModel.cs.meta | 12 + .../XMainClient/ProtoBuf/Meta/ValueMember.cs | 808 +++++++ .../XMainClient/ProtoBuf/Meta/ValueMember.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/NetObjectCache.cs | 256 +++ .../XMainClient/ProtoBuf/NetObjectCache.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/PrefixStyle.cs | 12 + .../XMainClient/ProtoBuf/PrefixStyle.cs.meta | 12 + .../ProtoBuf/ProtoAfterDeserializationAttribute.cs | 11 + .../ProtoAfterDeserializationAttribute.cs.meta | 12 + .../ProtoBuf/ProtoAfterSerializationAttribute.cs | 11 + .../ProtoAfterSerializationAttribute.cs.meta | 12 + .../ProtoBeforeDeserializationAttribute.cs | 11 + .../ProtoBeforeDeserializationAttribute.cs.meta | 12 + .../ProtoBuf/ProtoBeforeSerializationAttribute.cs | 11 + .../ProtoBeforeSerializationAttribute.cs.meta | 12 + .../XMainClient/ProtoBuf/ProtoContractAttribute.cs | 194 ++ .../ProtoBuf/ProtoContractAttribute.cs.meta | 12 + .../ProtoBuf/ProtoConverterAttribute.cs | 9 + .../ProtoBuf/ProtoConverterAttribute.cs.meta | 12 + .../XMainClient/ProtoBuf/ProtoEnumAttribute.cs | 44 + .../ProtoBuf/ProtoEnumAttribute.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ProtoException.cs | 19 + .../XMainClient/ProtoBuf/ProtoException.cs.meta | 12 + .../XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs | 9 + .../ProtoBuf/ProtoIgnoreAttribute.cs.meta | 12 + .../XMainClient/ProtoBuf/ProtoIncludeAttribute.cs | 73 + .../ProtoBuf/ProtoIncludeAttribute.cs.meta | 12 + .../XMainClient/ProtoBuf/ProtoMemberAttribute.cs | 233 ++ .../ProtoBuf/ProtoMemberAttribute.cs.meta | 12 + .../ProtoBuf/ProtoPartialIgnoreAttribute.cs | 28 + .../ProtoBuf/ProtoPartialIgnoreAttribute.cs.meta | 12 + .../ProtoBuf/ProtoPartialMemberAttribute.cs | 28 + .../ProtoBuf/ProtoPartialMemberAttribute.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ProtoReader.cs | 1838 ++++++++++++++++ .../XMainClient/ProtoBuf/ProtoReader.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs | 30 + .../XMainClient/ProtoBuf/ProtoTypeCode.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/ProtoWriter.cs | 1102 +++++++++ .../XMainClient/ProtoBuf/ProtoWriter.cs.meta | 12 + .../XMainClient/ProtoBuf/SerializationContext.cs | 57 + .../ProtoBuf/SerializationContext.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Serializer.cs | 268 +++ .../XMainClient/ProtoBuf/Serializer.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/Serializers.meta | 9 + .../ProtoBuf/Serializers/ArrayDecorator.cs | 172 ++ .../ProtoBuf/Serializers/ArrayDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/BlobSerializer.cs | 51 + .../ProtoBuf/Serializers/BlobSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/BooleanSerializer.cs | 49 + .../ProtoBuf/Serializers/BooleanSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/ByteSerializer.cs | 49 + .../ProtoBuf/Serializers/ByteSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/CharSerializer.cs | 33 + .../ProtoBuf/Serializers/CharSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/DateTimeSerializer.cs | 49 + .../Serializers/DateTimeSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/DecimalSerializer.cs | 49 + .../ProtoBuf/Serializers/DecimalSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/DefaultValueDecorator.cs | 64 + .../Serializers/DefaultValueDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/DoubleSerializer.cs | 49 + .../ProtoBuf/Serializers/DoubleSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/EnumSerializer.cs | 213 ++ .../ProtoBuf/Serializers/EnumSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/FieldDecorator.cs | 67 + .../ProtoBuf/Serializers/FieldDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/GuidSerializer.cs | 49 + .../ProtoBuf/Serializers/GuidSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/IProtoSerializer.cs | 17 + .../ProtoBuf/Serializers/IProtoSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/IProtoTypeSerializer.cs | 16 + .../Serializers/IProtoTypeSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/ISerializerProxy.cs | 9 + .../ProtoBuf/Serializers/ISerializerProxy.cs.meta | 12 + .../Serializers/ImmutableCollectionDecorator.cs | 252 +++ .../ImmutableCollectionDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/Int16Serializer.cs | 49 + .../ProtoBuf/Serializers/Int16Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/Int32Serializer.cs | 49 + .../ProtoBuf/Serializers/Int32Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/Int64Serializer.cs | 49 + .../ProtoBuf/Serializers/Int64Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/ListDecorator.cs | 365 +++ .../ProtoBuf/Serializers/ListDecorator.cs.meta | 12 + .../Serializers/MemberSpecifiedDecorator.cs | 68 + .../Serializers/MemberSpecifiedDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/NetObjectSerializer.cs | 56 + .../Serializers/NetObjectSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/NullDecorator.cs | 89 + .../ProtoBuf/Serializers/NullDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/ParseableSerializer.cs | 91 + .../Serializers/ParseableSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/PropertyDecorator.cs | 143 ++ .../ProtoBuf/Serializers/PropertyDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/ProtoDecoratorBase.cs | 30 + .../Serializers/ProtoDecoratorBase.cs.meta | 12 + .../ProtoBuf/Serializers/SByteSerializer.cs | 49 + .../ProtoBuf/Serializers/SByteSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/SingleSerializer.cs | 49 + .../ProtoBuf/Serializers/SingleSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/StringSerializer.cs | 49 + .../ProtoBuf/Serializers/StringSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/SubItemSerializer.cs | 96 + .../ProtoBuf/Serializers/SubItemSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/SurrogateSerializer.cs | 154 ++ .../Serializers/SurrogateSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/SystemTypeSerializer.cs | 49 + .../Serializers/SystemTypeSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/TagDecorator.cs | 105 + .../ProtoBuf/Serializers/TagDecorator.cs.meta | 12 + .../ProtoBuf/Serializers/TimeSpanSerializer.cs | 49 + .../Serializers/TimeSpanSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/TupleSerializer.cs | 211 ++ .../ProtoBuf/Serializers/TupleSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/TypeSerializer.cs | 445 ++++ .../ProtoBuf/Serializers/TypeSerializer.cs.meta | 12 + .../ProtoBuf/Serializers/UInt16Serializer.cs | 49 + .../ProtoBuf/Serializers/UInt16Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/UInt32Serializer.cs | 49 + .../ProtoBuf/Serializers/UInt32Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/UInt64Serializer.cs | 49 + .../ProtoBuf/Serializers/UInt64Serializer.cs.meta | 12 + .../ProtoBuf/Serializers/UriDecorator.cs | 50 + .../ProtoBuf/Serializers/UriDecorator.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/SubItemToken.cs | 14 + .../XMainClient/ProtoBuf/SubItemToken.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs | 15 + .../XMainClient/ProtoBuf/TimeSpanScale.cs.meta | 12 + .../Scripts/XMainClient/ProtoBuf/WireType.cs | 16 + .../Scripts/XMainClient/ProtoBuf/WireType.cs.meta | 12 + 176 files changed, 17100 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs.meta (limited to 'Client/Assets/Scripts/XMainClient/ProtoBuf') diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs new file mode 100644 index 00000000..50452c07 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs @@ -0,0 +1,659 @@ +using System; + +namespace ProtoBuf +{ + public static class BclHelpers + { + private const int FieldTimeSpanValue = 1; + + private const int FieldTimeSpanScale = 2; + + internal static readonly DateTime EpochOrigin = new DateTime(1970, 1, 1, 0, 0, 0, 0); + + private const int FieldDecimalLow = 1; + + private const int FieldDecimalHigh = 2; + + private const int FieldDecimalSignScale = 3; + + private const int FieldGuidLow = 1; + + private const int FieldGuidHigh = 2; + + private const int FieldExistingObjectKey = 1; + + private const int FieldNewObjectKey = 2; + + private const int FieldExistingTypeKey = 3; + + private const int FieldNewTypeKey = 4; + + private const int FieldTypeName = 8; + + private const int FieldObject = 10; + + [Flags] + public enum NetObjectOptions : byte + { + None = 0, + AsReference = 1, + DynamicType = 2, + UseConstructor = 4, + LateSet = 8 + } + + public static object GetUninitializedObject(Type type) + { + throw new NotSupportedException("Constructor-skipping is not supported on this platform"); + } + + public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest) + { + bool flag = dest == null; + if (flag) + { + throw new ArgumentNullException("dest"); + } + WireType wireType = dest.WireType; + if (wireType != WireType.Fixed64) + { + if (wireType - WireType.String > 1) + { + throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString()); + } + long num = timeSpan.Ticks; + bool flag2 = timeSpan == TimeSpan.MaxValue; + TimeSpanScale timeSpanScale; + if (flag2) + { + num = 1L; + timeSpanScale = TimeSpanScale.MinMax; + } + else + { + bool flag3 = timeSpan == TimeSpan.MinValue; + if (flag3) + { + num = -1L; + timeSpanScale = TimeSpanScale.MinMax; + } + else + { + bool flag4 = num % 864000000000L == 0L; + if (flag4) + { + timeSpanScale = TimeSpanScale.Days; + num /= 864000000000L; + } + else + { + bool flag5 = num % 36000000000L == 0L; + if (flag5) + { + timeSpanScale = TimeSpanScale.Hours; + num /= 36000000000L; + } + else + { + bool flag6 = num % 600000000L == 0L; + if (flag6) + { + timeSpanScale = TimeSpanScale.Minutes; + num /= 600000000L; + } + else + { + bool flag7 = num % 10000000L == 0L; + if (flag7) + { + timeSpanScale = TimeSpanScale.Seconds; + num /= 10000000L; + } + else + { + bool flag8 = num % 10000L == 0L; + if (flag8) + { + timeSpanScale = TimeSpanScale.Milliseconds; + num /= 10000L; + } + else + { + timeSpanScale = TimeSpanScale.Ticks; + } + } + } + } + } + } + } + SubItemToken token = ProtoWriter.StartSubItem(null, dest); + bool flag9 = num != 0L; + if (flag9) + { + ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest); + ProtoWriter.WriteInt64(num, dest); + } + bool flag10 = timeSpanScale > TimeSpanScale.Days; + if (flag10) + { + ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); + ProtoWriter.WriteInt32((int)timeSpanScale, dest); + } + ProtoWriter.EndSubItem(token, dest); + } + else + { + ProtoWriter.WriteInt64(timeSpan.Ticks, dest); + } + } + + public static TimeSpan ReadTimeSpan(ProtoReader source) + { + long num = BclHelpers.ReadTimeSpanTicks(source); + bool flag = num == long.MinValue; + TimeSpan result; + if (flag) + { + result = TimeSpan.MinValue; + } + else + { + bool flag2 = num == long.MaxValue; + if (flag2) + { + result = TimeSpan.MaxValue; + } + else + { + result = TimeSpan.FromTicks(num); + } + } + return result; + } + + public static DateTime ReadDateTime(ProtoReader source) + { + long num = BclHelpers.ReadTimeSpanTicks(source); + bool flag = num == long.MinValue; + DateTime result; + if (flag) + { + result = DateTime.MinValue; + } + else + { + bool flag2 = num == long.MaxValue; + if (flag2) + { + result = DateTime.MaxValue; + } + else + { + result = BclHelpers.EpochOrigin.AddTicks(num); + } + } + return result; + } + + public static void WriteDateTime(DateTime value, ProtoWriter dest) + { + bool flag = dest == null; + if (flag) + { + throw new ArgumentNullException("dest"); + } + WireType wireType = dest.WireType; + TimeSpan timeSpan; + if (wireType - WireType.String > 1) + { + timeSpan = value - BclHelpers.EpochOrigin; + } + else + { + bool flag2 = value == DateTime.MaxValue; + if (flag2) + { + timeSpan = TimeSpan.MaxValue; + } + else + { + bool flag3 = value == DateTime.MinValue; + if (flag3) + { + timeSpan = TimeSpan.MinValue; + } + else + { + timeSpan = value - BclHelpers.EpochOrigin; + } + } + } + BclHelpers.WriteTimeSpan(timeSpan, dest); + } + + private static long ReadTimeSpanTicks(ProtoReader source) + { + WireType wireType = source.WireType; + long result; + if (wireType != WireType.Fixed64) + { + if (wireType - WireType.String > 1) + { + throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString()); + } + SubItemToken token = ProtoReader.StartSubItem(source); + TimeSpanScale timeSpanScale = TimeSpanScale.Days; + long num = 0L; + int num2; + while ((num2 = source.ReadFieldHeader()) > 0) + { + int num3 = num2; + if (num3 != 1) + { + if (num3 != 2) + { + source.SkipField(); + } + else + { + timeSpanScale = (TimeSpanScale)source.ReadInt32(); + } + } + else + { + source.Assert(WireType.SignedVariant); + num = source.ReadInt64(); + } + } + ProtoReader.EndSubItem(token, source); + TimeSpanScale timeSpanScale2 = timeSpanScale; + switch (timeSpanScale2) + { + case TimeSpanScale.Days: + result = num * 864000000000L; + break; + case TimeSpanScale.Hours: + result = num * 36000000000L; + break; + case TimeSpanScale.Minutes: + result = num * 600000000L; + break; + case TimeSpanScale.Seconds: + result = num * 10000000L; + break; + case TimeSpanScale.Milliseconds: + result = num * 10000L; + break; + case TimeSpanScale.Ticks: + result = num; + break; + default: + { + if (timeSpanScale2 != TimeSpanScale.MinMax) + { + throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString()); + } + long num4 = num; + if (num4 != -1L) + { + if (num4 != 1L) + { + throw new ProtoException("Unknown min/max value: " + num.ToString()); + } + result = long.MaxValue; + } + else + { + result = long.MinValue; + } + break; + } + } + } + else + { + result = source.ReadInt64(); + } + return result; + } + + public static decimal ReadDecimal(ProtoReader reader) + { + ulong num = 0UL; + uint num2 = 0u; + uint num3 = 0u; + SubItemToken token = ProtoReader.StartSubItem(reader); + int num4; + while ((num4 = reader.ReadFieldHeader()) > 0) + { + switch (num4) + { + case 1: + num = reader.ReadUInt64(); + break; + case 2: + num2 = reader.ReadUInt32(); + break; + case 3: + num3 = reader.ReadUInt32(); + break; + default: + reader.SkipField(); + break; + } + } + ProtoReader.EndSubItem(token, reader); + bool flag = num == 0UL && num2 == 0u; + decimal result; + if (flag) + { + result = 0m; + } + else + { + int lo = (int)(num & /*(ulong)-1 */ulong.MaxValue); + int mid = (int)(num >> 32 & /*(ulong)-1*/ulong.MaxValue); + int hi = (int)num2; + bool isNegative = (num3 & 1u) == 1u; + byte scale = (byte)((num3 & 510u) >> 1); + result = new decimal(lo, mid, hi, isNegative, scale); + } + return result; + } + + public static void WriteDecimal(decimal value, ProtoWriter writer) + { + int[] bits = decimal.GetBits(value); + ulong num = (ulong)((ulong)((long)bits[1]) << 32); + ulong num2 = (ulong)((long)bits[0] & (long)(long.MaxValue)); + ulong num3 = num | num2; + uint num4 = (uint)bits[2]; + uint num5 = (uint)((bits[3] >> 15 & 510) | (bits[3] >> 31 & 1)); + SubItemToken token = ProtoWriter.StartSubItem(null, writer); + bool flag = num3 > 0UL; + if (flag) + { + ProtoWriter.WriteFieldHeader(1, WireType.Variant, writer); + ProtoWriter.WriteUInt64(num3, writer); + } + bool flag2 = num4 > 0u; + if (flag2) + { + ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer); + ProtoWriter.WriteUInt32(num4, writer); + } + bool flag3 = num5 > 0u; + if (flag3) + { + ProtoWriter.WriteFieldHeader(3, WireType.Variant, writer); + ProtoWriter.WriteUInt32(num5, writer); + } + ProtoWriter.EndSubItem(token, writer); + } + + public static void WriteGuid(Guid value, ProtoWriter dest) + { + byte[] data = value.ToByteArray(); + SubItemToken token = ProtoWriter.StartSubItem(null, dest); + bool flag = value != Guid.Empty; + if (flag) + { + ProtoWriter.WriteFieldHeader(1, WireType.Fixed64, dest); + ProtoWriter.WriteBytes(data, 0, 8, dest); + ProtoWriter.WriteFieldHeader(2, WireType.Fixed64, dest); + ProtoWriter.WriteBytes(data, 8, 8, dest); + } + ProtoWriter.EndSubItem(token, dest); + } + + public static Guid ReadGuid(ProtoReader source) + { + ulong num = 0UL; + ulong num2 = 0UL; + SubItemToken token = ProtoReader.StartSubItem(source); + int num3; + while ((num3 = source.ReadFieldHeader()) > 0) + { + int num4 = num3; + if (num4 != 1) + { + if (num4 != 2) + { + source.SkipField(); + } + else + { + num2 = source.ReadUInt64(); + } + } + else + { + num = source.ReadUInt64(); + } + } + ProtoReader.EndSubItem(token, source); + bool flag = num == 0UL && num2 == 0UL; + Guid result; + if (flag) + { + result = Guid.Empty; + } + else + { + uint num5 = (uint)(num >> 32); + uint a = (uint)num; + uint num6 = (uint)(num2 >> 32); + uint num7 = (uint)num2; + result = new Guid((int)a, (short)num5, (short)(num5 >> 16), (byte)num7, (byte)(num7 >> 8), (byte)(num7 >> 16), (byte)(num7 >> 24), (byte)num6, (byte)(num6 >> 8), (byte)(num6 >> 16), (byte)(num6 >> 24)); + } + return result; + } + + public static object ReadNetObject(object value, ProtoReader source, int key, Type type, BclHelpers.NetObjectOptions options) + { + SubItemToken token = ProtoReader.StartSubItem(source); + int num = -1; + int num2 = -1; + int num3; + while ((num3 = source.ReadFieldHeader()) > 0) + { + switch (num3) + { + case 1: + { + int key2 = source.ReadInt32(); + value = source.NetCache.GetKeyedObject(key2); + break; + } + case 2: + num = source.ReadInt32(); + break; + case 3: + { + int key2 = source.ReadInt32(); + type = (Type)source.NetCache.GetKeyedObject(key2); + key = source.GetTypeKey(ref type); + break; + } + case 4: + num2 = source.ReadInt32(); + break; + case 5: + case 6: + case 7: + case 9: + goto IL_27E; + case 8: + { + string text = source.ReadString(); + type = source.DeserializeType(text); + bool flag = type == null; + if (flag) + { + throw new ProtoException("Unable to resolve type: " + text + " (you can use the TypeModel.DynamicTypeFormatting event to provide a custom mapping)"); + } + bool flag2 = type == typeof(string); + if (flag2) + { + key = -1; + } + else + { + key = source.GetTypeKey(ref type); + bool flag3 = key < 0; + if (flag3) + { + throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name); + } + } + break; + } + case 10: + { + bool flag4 = type == typeof(string); + bool flag5 = value == null; + bool flag6 = flag5 && (flag4 || (options & BclHelpers.NetObjectOptions.LateSet) > BclHelpers.NetObjectOptions.None); + bool flag7 = num >= 0 && !flag6; + if (flag7) + { + bool flag8 = value == null; + if (flag8) + { + source.TrapNextObject(num); + } + else + { + source.NetCache.SetKeyedObject(num, value); + } + bool flag9 = num2 >= 0; + if (flag9) + { + source.NetCache.SetKeyedObject(num2, type); + } + } + object obj = value; + bool flag10 = flag4; + if (flag10) + { + value = source.ReadString(); + } + else + { + value = ProtoReader.ReadTypedObject(obj, key, source, type); + } + bool flag11 = num >= 0; + if (flag11) + { + bool flag12 = flag5 && !flag6; + if (flag12) + { + obj = source.NetCache.GetKeyedObject(num); + } + bool flag13 = flag6; + if (flag13) + { + source.NetCache.SetKeyedObject(num, value); + bool flag14 = num2 >= 0; + if (flag14) + { + source.NetCache.SetKeyedObject(num2, type); + } + } + } + bool flag15 = num >= 0 && !flag6 && obj != value; + if (flag15) + { + throw new ProtoException("A reference-tracked object changed reference during deserialization"); + } + bool flag16 = num < 0 && num2 >= 0; + if (flag16) + { + source.NetCache.SetKeyedObject(num2, type); + } + break; + } + default: + goto IL_27E; + } + continue; + IL_27E: + source.SkipField(); + } + bool flag17 = num >= 0 && (options & BclHelpers.NetObjectOptions.AsReference) == BclHelpers.NetObjectOptions.None; + if (flag17) + { + throw new ProtoException("Object key in input stream, but reference-tracking was not expected"); + } + ProtoReader.EndSubItem(token, source); + return value; + } + + public static void WriteNetObject(object value, ProtoWriter dest, int key, BclHelpers.NetObjectOptions options) + { + bool flag = dest == null; + if (flag) + { + throw new ArgumentNullException("dest"); + } + bool flag2 = (options & BclHelpers.NetObjectOptions.DynamicType) > BclHelpers.NetObjectOptions.None; + bool flag3 = (options & BclHelpers.NetObjectOptions.AsReference) > BclHelpers.NetObjectOptions.None; + WireType wireType = dest.WireType; + SubItemToken token = ProtoWriter.StartSubItem(null, dest); + bool flag4 = true; + bool flag5 = flag3; + if (flag5) + { + bool flag6; + int value2 = dest.NetCache.AddObjectKey(value, out flag6); + ProtoWriter.WriteFieldHeader(flag6 ? 1 : 2, WireType.Variant, dest); + ProtoWriter.WriteInt32(value2, dest); + bool flag7 = flag6; + if (flag7) + { + flag4 = false; + } + } + bool flag8 = flag4; + if (flag8) + { + bool flag9 = flag2; + if (flag9) + { + Type type = value.GetType(); + bool flag10 = !(value is string); + if (flag10) + { + key = dest.GetTypeKey(ref type); + bool flag11 = key < 0; + if (flag11) + { + throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name); + } + } + bool flag12; + int value3 = dest.NetCache.AddObjectKey(type, out flag12); + ProtoWriter.WriteFieldHeader(flag12 ? 3 : 4, WireType.Variant, dest); + ProtoWriter.WriteInt32(value3, dest); + bool flag13 = !flag12; + if (flag13) + { + ProtoWriter.WriteFieldHeader(8, WireType.String, dest); + ProtoWriter.WriteString(dest.SerializeType(type), dest); + } + } + ProtoWriter.WriteFieldHeader(10, wireType, dest); + bool flag14 = value is string; + if (flag14) + { + ProtoWriter.WriteString((string)value, dest); + } + else + { + ProtoWriter.WriteObject(value, key, dest); + } + } + ProtoWriter.EndSubItem(token, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs.meta new file mode 100644 index 00000000..11421dcc --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: cb4f7e7bf29811b48a2af2a46cf7c0c3 +timeCreated: 1611404545 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs new file mode 100644 index 00000000..2bae502e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs @@ -0,0 +1,72 @@ +using System; +using System.IO; + +namespace ProtoBuf +{ + public sealed class BufferExtension : IExtension + { + private byte[] buffer; + + int IExtension.GetLength() + { + return (this.buffer == null) ? 0 : this.buffer.Length; + } + + Stream IExtension.BeginAppend() + { + return new MemoryStream(); + } + + void IExtension.EndAppend(Stream stream, bool commit) + { + try + { + int num = 0; + bool flag = commit && (num = (int)stream.Length) > 0; + if (flag) + { + MemoryStream memoryStream = (MemoryStream)stream; + bool flag2 = this.buffer == null; + if (flag2) + { + this.buffer = memoryStream.ToArray(); + } + else + { + int num2 = this.buffer.Length; + byte[] to = new byte[num2 + num]; + Helpers.BlockCopy(this.buffer, 0, to, 0, num2); + Helpers.BlockCopy(memoryStream.GetBuffer(), 0, to, num2, num); + this.buffer = to; + } + } + } + finally + { + if (stream != null) + { + ((IDisposable)stream).Dispose(); + } + } + } + + Stream IExtension.BeginQuery() + { + return (this.buffer == null) ? Stream.Null : new MemoryStream(this.buffer); + } + + void IExtension.EndQuery(Stream stream) + { + try + { + } + finally + { + if (stream != null) + { + ((IDisposable)stream).Dispose(); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs.meta new file mode 100644 index 00000000..6a9c6aa6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferExtension.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 093a887d01b82564b920e35171554124 +timeCreated: 1611403151 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs new file mode 100644 index 00000000..36aabc3a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs @@ -0,0 +1,87 @@ +using System; +using System.Threading; + +namespace ProtoBuf +{ + internal sealed class BufferPool + { + private const int PoolSize = 20; + + internal const int BufferLength = 1024; + + private static readonly object[] pool = new object[20]; + + internal static void Flush() + { + for (int i = 0; i < BufferPool.pool.Length; i++) + { + Interlocked.Exchange(ref BufferPool.pool[i], null); + } + } + + private BufferPool() + { + } + + internal static byte[] GetBuffer() + { + for (int i = 0; i < BufferPool.pool.Length; i++) + { + object obj; + bool flag = (obj = Interlocked.Exchange(ref BufferPool.pool[i], null)) != null; + if (flag) + { + return (byte[])obj; + } + } + return new byte[1024]; + } + + internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes) + { + Helpers.DebugAssert(buffer != null); + Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length); + Helpers.DebugAssert(copyFromIndex >= 0); + Helpers.DebugAssert(copyBytes >= 0); + int num = buffer.Length * 2; + bool flag = num < toFitAtLeastBytes; + if (flag) + { + num = toFitAtLeastBytes; + } + byte[] array = new byte[num]; + bool flag2 = copyBytes > 0; + if (flag2) + { + Helpers.BlockCopy(buffer, copyFromIndex, array, 0, copyBytes); + } + bool flag3 = buffer.Length == 1024; + if (flag3) + { + BufferPool.ReleaseBufferToPool(ref buffer); + } + buffer = array; + } + + internal static void ReleaseBufferToPool(ref byte[] buffer) + { + bool flag = buffer == null; + if (!flag) + { + bool flag2 = buffer.Length == 1024; + if (flag2) + { + for (int i = 0; i < BufferPool.pool.Length; i++) + { + bool flag3 = Interlocked.CompareExchange(ref BufferPool.pool[i], buffer, null) == null; + if (flag3) + { + break; + } + } + } + buffer = null; + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs.meta new file mode 100644 index 00000000..32eb47ff --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BufferPool.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: b9f1916d7d8c6984e979af269fcde17b +timeCreated: 1611404433 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs new file mode 100644 index 00000000..e53b59d5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs @@ -0,0 +1,13 @@ +using System; + +namespace ProtoBuf +{ + public enum DataFormat + { + Default, + ZigZag, + TwosComplement, + FixedSize, + Group + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs.meta new file mode 100644 index 00000000..e19f0dd3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/DataFormat.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f6699ef9eb3af6941a78cb34b4d81ef9 +timeCreated: 1611404881 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs new file mode 100644 index 00000000..3c33a044 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + public abstract class Extensible : IExtensible + { + private IExtension extensionObject; + + IExtension IExtensible.GetExtensionObject(bool createIfMissing) + { + return this.GetExtensionObject(createIfMissing); + } + + protected virtual IExtension GetExtensionObject(bool createIfMissing) + { + return Extensible.GetExtensionObject(ref this.extensionObject, createIfMissing); + } + + public static IExtension GetExtensionObject(ref IExtension extensionObject, bool createIfMissing) + { + bool flag = createIfMissing && extensionObject == null; + if (flag) + { + extensionObject = new BufferExtension(); + } + return extensionObject; + } + + public static void AppendValue(IExtensible instance, int tag, TValue value) + { + Extensible.AppendValue(instance, tag, DataFormat.Default, value); + } + + public static void AppendValue(IExtensible instance, int tag, DataFormat format, TValue value) + { + ExtensibleUtil.AppendExtendValue(RuntimeTypeModel.Default, instance, tag, format, value); + } + + public static TValue GetValue(IExtensible instance, int tag) + { + return Extensible.GetValue(instance, tag, DataFormat.Default); + } + + public static TValue GetValue(IExtensible instance, int tag, DataFormat format) + { + TValue result; + Extensible.TryGetValue(instance, tag, format, out result); + return result; + } + + public static bool TryGetValue(IExtensible instance, int tag, out TValue value) + { + return Extensible.TryGetValue(instance, tag, DataFormat.Default, out value); + } + + public static bool TryGetValue(IExtensible instance, int tag, DataFormat format, out TValue value) + { + return Extensible.TryGetValue(instance, tag, format, false, out value); + } + + public static bool TryGetValue(IExtensible instance, int tag, DataFormat format, bool allowDefinedTag, out TValue value) + { + value = default(TValue); + bool result = false; + foreach (TValue tvalue in ExtensibleUtil.GetExtendedValues(instance, tag, format, true, allowDefinedTag)) + { + value = tvalue; + result = true; + } + return result; + } + + public static IEnumerable GetValues(IExtensible instance, int tag) + { + return ExtensibleUtil.GetExtendedValues(instance, tag, DataFormat.Default, false, false); + } + + public static IEnumerable GetValues(IExtensible instance, int tag, DataFormat format) + { + return ExtensibleUtil.GetExtendedValues(instance, tag, format, false, false); + } + + public static bool TryGetValue(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool allowDefinedTag, out object value) + { + value = null; + bool result = false; + foreach (object obj in ExtensibleUtil.GetExtendedValues(model, type, instance, tag, format, true, allowDefinedTag)) + { + value = obj; + result = true; + } + return result; + } + + public static IEnumerable GetValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format) + { + return ExtensibleUtil.GetExtendedValues(model, type, instance, tag, format, false, false); + } + + public static void AppendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) + { + ExtensibleUtil.AppendExtendValue(model, instance, tag, format, value); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs.meta new file mode 100644 index 00000000..f8ccdbf9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Extensible.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: d9283a99346cfed4297e56586e046bf8 +timeCreated: 1611404642 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs new file mode 100644 index 00000000..c4105259 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + internal static class ExtensibleUtil + { + internal static IEnumerable GetExtendedValues(IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) + { + foreach (object obj in ExtensibleUtil.GetExtendedValues(RuntimeTypeModel.Default, typeof(TValue), instance, tag, format, singleton, allowDefinedTag)) + { + TValue value = (TValue)((object)obj); + yield return value; + value = default(TValue); + } + IEnumerator enumerator = null; + yield break; + yield break; + } + + internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + bool flag2 = tag <= 0; + if (flag2) + { + throw new ArgumentOutOfRangeException("tag"); + } + IExtension extn = instance.GetExtensionObject(false); + bool flag3 = extn == null; + if (flag3) + { + yield break; + } + Stream stream = extn.BeginQuery(); + object value = null; + ProtoReader reader = null; + try + { + SerializationContext ctx = new SerializationContext(); + reader = ProtoReader.Create(stream, model, ctx, -1); + while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, false, false, false) && value != null) + { + bool flag4 = !singleton; + if (flag4) + { + yield return value; + value = null; + } + } + bool flag5 = singleton && value != null; + if (flag5) + { + yield return value; + } + ctx = null; + } + finally + { + ProtoReader.Recycle(reader); + extn.EndQuery(stream); + } + yield break; + yield break; + } + + internal static void AppendExtendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + bool flag2 = value == null; + if (flag2) + { + throw new ArgumentNullException("value"); + } + IExtension extensionObject = instance.GetExtensionObject(true); + bool flag3 = extensionObject == null; + if (flag3) + { + throw new InvalidOperationException("No extension object available; appended data would be lost."); + } + bool commit = false; + Stream stream = extensionObject.BeginAppend(); + try + { + using (ProtoWriter protoWriter = new ProtoWriter(stream, model, null)) + { + model.TrySerializeAuxiliaryType(protoWriter, null, format, tag, value, false); + protoWriter.Close(); + } + commit = true; + } + finally + { + extensionObject.EndAppend(stream, commit); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs.meta new file mode 100644 index 00000000..b01930e8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ExtensibleUtil.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 6bc96ccf173fbeb428e12bc9b4771977 +timeCreated: 1611403893 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs new file mode 100644 index 00000000..7d4c3711 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs @@ -0,0 +1,341 @@ +using System; +using System.Diagnostics; +using System.Reflection; +using System.Text; + +namespace ProtoBuf +{ + internal sealed class Helpers + { + public static readonly Type[] EmptyTypes = Type.EmptyTypes; + + private Helpers() + { + } + + public static StringBuilder AppendLine(StringBuilder builder) + { + return builder.AppendLine(); + } + + public static bool IsNullOrEmpty(string value) + { + return value == null || value.Length == 0; + } + + [Conditional("DEBUG")] + public static void DebugWriteLine(string message, object obj) + { + string str; + try + { + str = ((obj == null) ? "(null)" : obj.ToString()); + } + catch + { + str = "(exception)"; + } + Helpers.DebugWriteLine(message + ": " + str); + } + + [Conditional("DEBUG")] + public static void DebugWriteLine(string message) + { + Debug.WriteLine(message); + } + + [Conditional("TRACE")] + public static void TraceWriteLine(string message) + { + Trace.WriteLine(message); + } + + [Conditional("DEBUG")] + public static void DebugAssert(bool condition, string message) + { + bool flag = !condition; + if (flag) + { + Debug.Assert(false, message); + } + } + + [Conditional("DEBUG")] + public static void DebugAssert(bool condition, string message, params object[] args) + { + bool flag = !condition; + if (flag) + { + Helpers.DebugAssert(false, string.Format(message, args)); + } + } + + [Conditional("DEBUG")] + public static void DebugAssert(bool condition) + { + bool flag = !condition && System.Diagnostics.Debugger.IsAttached; + if (flag) + { + System.Diagnostics.Debugger.Break(); + } + Debug.Assert(condition); + } + + public static void Sort(int[] keys, object[] values) + { + bool flag; + do + { + flag = false; + for (int i = 1; i < keys.Length; i++) + { + bool flag2 = keys[i - 1] > keys[i]; + if (flag2) + { + int num = keys[i]; + keys[i] = keys[i - 1]; + keys[i - 1] = num; + object obj = values[i]; + values[i] = values[i - 1]; + values[i - 1] = obj; + flag = true; + } + } + } + while (flag); + } + + public static void BlockCopy(byte[] from, int fromIndex, byte[] to, int toIndex, int count) + { + Buffer.BlockCopy(from, fromIndex, to, toIndex, count); + } + + public static bool IsInfinity(float value) + { + return float.IsInfinity(value); + } + + internal static MethodInfo GetInstanceMethod(Type declaringType, string name) + { + return declaringType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + } + + internal static MethodInfo GetStaticMethod(Type declaringType, string name) + { + return declaringType.GetMethod(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + } + + internal static MethodInfo GetInstanceMethod(Type declaringType, string name, Type[] types) + { + bool flag = types == null; + if (flag) + { + types = Helpers.EmptyTypes; + } + return declaringType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, types, null); + } + + internal static bool IsSubclassOf(Type type, Type baseClass) + { + return type.IsSubclassOf(baseClass); + } + + public static bool IsInfinity(double value) + { + return double.IsInfinity(value); + } + + public static ProtoTypeCode GetTypeCode(Type type) + { + TypeCode typeCode = Type.GetTypeCode(type); + switch (typeCode) + { + case TypeCode.Empty: + case TypeCode.Boolean: + case TypeCode.Char: + case TypeCode.SByte: + case TypeCode.Byte: + case TypeCode.Int16: + case TypeCode.UInt16: + case TypeCode.Int32: + case TypeCode.UInt32: + case TypeCode.Int64: + case TypeCode.UInt64: + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + case TypeCode.DateTime: + case TypeCode.String: + return (ProtoTypeCode)typeCode; + } + bool flag = type == typeof(TimeSpan); + ProtoTypeCode result; + if (flag) + { + result = ProtoTypeCode.TimeSpan; + } + else + { + bool flag2 = type == typeof(Guid); + if (flag2) + { + result = ProtoTypeCode.Guid; + } + else + { + bool flag3 = type == typeof(Uri); + if (flag3) + { + result = ProtoTypeCode.Uri; + } + else + { + bool flag4 = type == typeof(byte[]); + if (flag4) + { + result = ProtoTypeCode.ByteArray; + } + else + { + bool flag5 = type == typeof(Type); + if (flag5) + { + result = ProtoTypeCode.Type; + } + else + { + result = ProtoTypeCode.Unknown; + } + } + } + } + } + return result; + } + + internal static Type GetUnderlyingType(Type type) + { + return Nullable.GetUnderlyingType(type); + } + + internal static bool IsValueType(Type type) + { + return type.IsValueType; + } + + internal static bool IsEnum(Type type) + { + return type.IsEnum; + } + + internal static MethodInfo GetGetMethod(PropertyInfo property, bool nonPublic, bool allowInternal) + { + bool flag = property == null; + MethodInfo result; + if (flag) + { + result = null; + } + else + { + MethodInfo methodInfo = property.GetGetMethod(nonPublic); + bool flag2 = methodInfo == null && !nonPublic && allowInternal; + if (flag2) + { + methodInfo = property.GetGetMethod(true); + bool flag3 = methodInfo == null && !methodInfo.IsAssembly && !methodInfo.IsFamilyOrAssembly; + if (flag3) + { + methodInfo = null; + } + } + result = methodInfo; + } + return result; + } + + internal static MethodInfo GetSetMethod(PropertyInfo property, bool nonPublic, bool allowInternal) + { + bool flag = property == null; + MethodInfo result; + if (flag) + { + result = null; + } + else + { + MethodInfo methodInfo = property.GetSetMethod(nonPublic); + bool flag2 = methodInfo == null && !nonPublic && allowInternal; + if (flag2) + { + methodInfo = property.GetGetMethod(true); + bool flag3 = methodInfo == null && !methodInfo.IsAssembly && !methodInfo.IsFamilyOrAssembly; + if (flag3) + { + methodInfo = null; + } + } + result = methodInfo; + } + return result; + } + + internal static ConstructorInfo GetConstructor(Type type, Type[] parameterTypes, bool nonPublic) + { + return type.GetConstructor(nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public), null, parameterTypes, null); + } + + internal static ConstructorInfo[] GetConstructors(Type type, bool nonPublic) + { + return type.GetConstructors(nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public)); + } + + internal static PropertyInfo GetProperty(Type type, string name, bool nonPublic) + { + return type.GetProperty(name, nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public)); + } + + internal static object ParseEnum(Type type, string value) + { + return Enum.Parse(type, value, true); + } + + internal static MemberInfo[] GetInstanceFieldsAndProperties(Type type, bool publicOnly) + { + BindingFlags bindingAttr = publicOnly ? (BindingFlags.Instance | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + PropertyInfo[] properties = type.GetProperties(bindingAttr); + FieldInfo[] fields = type.GetFields(bindingAttr); + MemberInfo[] array = new MemberInfo[fields.Length + properties.Length]; + properties.CopyTo(array, 0); + fields.CopyTo(array, properties.Length); + return array; + } + + internal static Type GetMemberType(MemberInfo member) + { + MemberTypes memberType = member.MemberType; + Type result; + if (memberType != MemberTypes.Field) + { + if (memberType != MemberTypes.Property) + { + result = null; + } + else + { + result = ((PropertyInfo)member).PropertyType; + } + } + else + { + result = ((FieldInfo)member).FieldType; + } + return result; + } + + internal static bool IsAssignableFrom(Type target, Type type) + { + return target.IsAssignableFrom(type); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs.meta new file mode 100644 index 00000000..58025d0d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Helpers.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 2dafd29875705334ea80c76b5cb82b63 +timeCreated: 1611403507 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs new file mode 100644 index 00000000..941b86a9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs @@ -0,0 +1,9 @@ +using System; + +namespace ProtoBuf +{ + public interface IExtensible + { + IExtension GetExtensionObject(bool createIfMissing); + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs.meta new file mode 100644 index 00000000..dc34ff39 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtensible.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5ff47a5fb05919b45bfddeb18f37939e +timeCreated: 1611403831 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs new file mode 100644 index 00000000..001754df --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs @@ -0,0 +1,18 @@ +using System; +using System.IO; + +namespace ProtoBuf +{ + public interface IExtension + { + Stream BeginAppend(); + + void EndAppend(Stream stream, bool commit); + + Stream BeginQuery(); + + void EndQuery(Stream stream); + + int GetLength(); + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs.meta new file mode 100644 index 00000000..60a55cf0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/IExtension.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 83f33cea356663a419170cd907d6b9ce +timeCreated: 1611404046 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs new file mode 100644 index 00000000..ca310765 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs @@ -0,0 +1,11 @@ +using System; + +namespace ProtoBuf +{ + public enum ImplicitFields + { + None, + AllPublic, + AllFields + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs.meta new file mode 100644 index 00000000..19e70a8c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ImplicitFields.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: b9802b45bb8732c479aa537a633885a5 +timeCreated: 1611404410 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs new file mode 100644 index 00000000..70b37e60 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs @@ -0,0 +1,16 @@ +using System; + +namespace ProtoBuf +{ + [Flags] + public enum MemberSerializationOptions + { + None = 0, + Packed = 1, + Required = 2, + AsReference = 4, + DynamicType = 8, + OverwriteList = 16, + AsReferenceHasValue = 32 + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs.meta new file mode 100644 index 00000000..a9a95b42 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/MemberSerializationOptions.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ae30f2bfd7c00b347acefae14066d26a +timeCreated: 1611404338 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta.meta new file mode 100644 index 00000000..1cfb21e4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 2b782c6e2c04dd848a0802da8522a8b6 +folderAsset: yes +timeCreated: 1611402943 +licenseType: Free +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs new file mode 100644 index 00000000..4fb2059b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs @@ -0,0 +1,117 @@ +using System; +using System.Reflection; + +namespace ProtoBuf.Meta +{ + internal abstract class AttributeMap + { + public abstract Type AttributeType { get; } + + public abstract object Target { get; } + + private sealed class ReflectionAttributeMap : AttributeMap + { + public override object Target + { + get + { + return this.attribute; + } + } + + public override Type AttributeType + { + get + { + return this.attribute.GetType(); + } + } + + private readonly Attribute attribute; + + public override bool TryGet(string key, bool publicOnly, out object value) + { + foreach (MemberInfo memberInfo in Helpers.GetInstanceFieldsAndProperties(this.attribute.GetType(), publicOnly)) + { + bool flag = string.Equals(memberInfo.Name, key, StringComparison.OrdinalIgnoreCase); + if (flag) + { + PropertyInfo propertyInfo = memberInfo as PropertyInfo; + bool flag2 = propertyInfo != null; + bool result; + if (flag2) + { + value = propertyInfo.GetValue(this.attribute, null); + result = true; + } + else + { + FieldInfo fieldInfo = memberInfo as FieldInfo; + bool flag3 = fieldInfo != null; + if (!flag3) + { + throw new NotSupportedException(memberInfo.GetType().Name); + } + value = fieldInfo.GetValue(this.attribute); + result = true; + } + return result; + } + } + value = null; + return false; + } + + public ReflectionAttributeMap(Attribute attribute) + { + this.attribute = attribute; + } + } + + [Obsolete("Please use AttributeType instead")] + public new Type GetType() + { + return this.AttributeType; + } + + public abstract bool TryGet(string key, bool publicOnly, out object value); + + public bool TryGet(string key, out object value) + { + return this.TryGet(key, true, out value); + } + + public static AttributeMap[] Create(TypeModel model, Type type, bool inherit) + { + object[] customAttributes = type.GetCustomAttributes(inherit); + AttributeMap[] array = new AttributeMap[customAttributes.Length]; + for (int i = 0; i < customAttributes.Length; i++) + { + array[i] = new AttributeMap.ReflectionAttributeMap((Attribute)customAttributes[i]); + } + return array; + } + + public static AttributeMap[] Create(TypeModel model, MemberInfo member, bool inherit) + { + object[] customAttributes = member.GetCustomAttributes(inherit); + AttributeMap[] array = new AttributeMap[customAttributes.Length]; + for (int i = 0; i < customAttributes.Length; i++) + { + array[i] = new AttributeMap.ReflectionAttributeMap((Attribute)customAttributes[i]); + } + return array; + } + + public static AttributeMap[] Create(TypeModel model, Assembly assembly) + { + object[] customAttributes = assembly.GetCustomAttributes(false); + AttributeMap[] array = new AttributeMap[customAttributes.Length]; + for (int i = 0; i < customAttributes.Length; i++) + { + array[i] = new AttributeMap.ReflectionAttributeMap((Attribute)customAttributes[i]); + } + return array; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs.meta new file mode 100644 index 00000000..484bca84 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/AttributeMap.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 87e043055f5d7a44eb9f66262b09652e +timeCreated: 1611404081 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs new file mode 100644 index 00000000..68acbe62 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs @@ -0,0 +1,337 @@ +using System; +using System.Collections; + +namespace ProtoBuf.Meta +{ + internal class BasicList : IEnumerable + { + public object this[int index] + { + get + { + return this.head[index]; + } + } + + public int Count + { + get + { + return this.head.Length; + } + } + + private static readonly BasicList.Node nil = new BasicList.Node(null, 0); + + protected BasicList.Node head = BasicList.nil; + + public struct NodeEnumerator : IEnumerator + { + public object Current + { + get + { + return this.node[this.position]; + } + } + + private int position; + + private readonly BasicList.Node node; + + internal NodeEnumerator(BasicList.Node node) + { + this.position = -1; + this.node = node; + } + + void IEnumerator.Reset() + { + this.position = -1; + } + + public bool MoveNext() + { + int length = this.node.Length; + bool result; + if (this.position <= length) + { + int num = this.position + 1; + this.position = num; + result = (num < length); + } + else + { + result = false; + } + return result; + } + } + + internal sealed class Node + { + public object this[int index] + { + get + { + bool flag = index >= 0 && index < this.length; + if (flag) + { + return this.data[index]; + } + throw new ArgumentOutOfRangeException("index"); + } + set + { + bool flag = index >= 0 && index < this.length; + if (flag) + { + this.data[index] = value; + return; + } + throw new ArgumentOutOfRangeException("index"); + } + } + + public int Length + { + get + { + return this.length; + } + } + + private readonly object[] data; + + private int length; + + internal Node(object[] data, int length) + { + Helpers.DebugAssert((data == null && length == 0) || (data != null && length > 0 && length <= data.Length)); + this.data = data; + this.length = length; + } + + public void RemoveLastWithMutate() + { + bool flag = this.length == 0; + if (flag) + { + throw new InvalidOperationException(); + } + this.length--; + } + + public BasicList.Node Append(object value) + { + int num = this.length + 1; + bool flag = this.data == null; + object[] array; + if (flag) + { + array = new object[10]; + } + else + { + bool flag2 = this.length == this.data.Length; + if (flag2) + { + array = new object[this.data.Length * 2]; + Array.Copy(this.data, array, this.length); + } + else + { + array = this.data; + } + } + array[this.length] = value; + return new BasicList.Node(array, num); + } + + public BasicList.Node Trim() + { + bool flag = this.length == 0 || this.length == this.data.Length; + BasicList.Node result; + if (flag) + { + result = this; + } + else + { + object[] destinationArray = new object[this.length]; + Array.Copy(this.data, destinationArray, this.length); + result = new BasicList.Node(destinationArray, this.length); + } + return result; + } + + internal int IndexOfString(string value) + { + for (int i = 0; i < this.length; i++) + { + bool flag = value == (string)this.data[i]; + if (flag) + { + return i; + } + } + return -1; + } + + internal int IndexOfReference(object instance) + { + for (int i = 0; i < this.length; i++) + { + bool flag = instance == this.data[i]; + if (flag) + { + return i; + } + } + return -1; + } + + internal int IndexOf(BasicList.MatchPredicate predicate, object ctx) + { + for (int i = 0; i < this.length; i++) + { + bool flag = predicate(this.data[i], ctx); + if (flag) + { + return i; + } + } + return -1; + } + + internal void CopyTo(Array array, int offset) + { + bool flag = this.length > 0; + if (flag) + { + Array.Copy(this.data, 0, array, offset, this.length); + } + } + + internal void Clear() + { + bool flag = this.data != null; + if (flag) + { + Array.Clear(this.data, 0, this.data.Length); + } + this.length = 0; + } + } + + internal delegate bool MatchPredicate(object value, object ctx); + + internal sealed class Group + { + public readonly int First; + + public readonly BasicList Items; + + public Group(int first) + { + this.First = first; + this.Items = new BasicList(); + } + } + + public void CopyTo(Array array, int offset) + { + this.head.CopyTo(array, offset); + } + + public int Add(object value) + { + return (this.head = this.head.Append(value)).Length - 1; + } + + public void Trim() + { + this.head = this.head.Trim(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return new BasicList.NodeEnumerator(this.head); + } + + public BasicList.NodeEnumerator GetEnumerator() + { + return new BasicList.NodeEnumerator(this.head); + } + + public void Clear() + { + this.head = BasicList.nil; + } + + internal int IndexOf(BasicList.MatchPredicate predicate, object ctx) + { + return this.head.IndexOf(predicate, ctx); + } + + internal int IndexOfString(string value) + { + return this.head.IndexOfString(value); + } + + internal int IndexOfReference(object instance) + { + return this.head.IndexOfReference(instance); + } + + internal bool Contains(object value) + { + foreach (object objA in this) + { + bool flag = object.Equals(objA, value); + if (flag) + { + return true; + } + } + return false; + } + + internal static BasicList GetContiguousGroups(int[] keys, object[] values) + { + bool flag = keys == null; + if (flag) + { + throw new ArgumentNullException("keys"); + } + bool flag2 = values == null; + if (flag2) + { + throw new ArgumentNullException("values"); + } + bool flag3 = values.Length < keys.Length; + if (flag3) + { + throw new ArgumentException("Not all keys are covered by values", "values"); + } + BasicList basicList = new BasicList(); + BasicList.Group group = null; + for (int i = 0; i < keys.Length; i++) + { + bool flag4 = i == 0 || keys[i] != keys[i - 1]; + if (flag4) + { + group = null; + } + bool flag5 = group == null; + if (flag5) + { + group = new BasicList.Group(keys[i]); + basicList.Add(group); + } + group.Items.Add(values[i]); + } + return basicList; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs.meta new file mode 100644 index 00000000..de4e1a55 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/BasicList.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 6a87ac069938105429795f2d59f09a44 +timeCreated: 1611403888 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs new file mode 100644 index 00000000..d0e7c11a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs @@ -0,0 +1,160 @@ +using System; +using System.Reflection; + +namespace ProtoBuf.Meta +{ + public class CallbackSet + { + internal MethodInfo this[TypeModel.CallbackType callbackType] + { + get + { + MethodInfo result; + switch (callbackType) + { + case TypeModel.CallbackType.BeforeSerialize: + result = this.beforeSerialize; + break; + case TypeModel.CallbackType.AfterSerialize: + result = this.afterSerialize; + break; + case TypeModel.CallbackType.BeforeDeserialize: + result = this.beforeDeserialize; + break; + case TypeModel.CallbackType.AfterDeserialize: + result = this.afterDeserialize; + break; + default: + throw new ArgumentException("Callback type not supported: " + callbackType.ToString(), "callbackType"); + } + return result; + } + } + + public MethodInfo BeforeSerialize + { + get + { + return this.beforeSerialize; + } + set + { + this.beforeSerialize = this.SanityCheckCallback(this.metaType.Model, value); + } + } + + public MethodInfo BeforeDeserialize + { + get + { + return this.beforeDeserialize; + } + set + { + this.beforeDeserialize = this.SanityCheckCallback(this.metaType.Model, value); + } + } + + public MethodInfo AfterSerialize + { + get + { + return this.afterSerialize; + } + set + { + this.afterSerialize = this.SanityCheckCallback(this.metaType.Model, value); + } + } + + public MethodInfo AfterDeserialize + { + get + { + return this.afterDeserialize; + } + set + { + this.afterDeserialize = this.SanityCheckCallback(this.metaType.Model, value); + } + } + + public bool NonTrivial + { + get + { + return this.beforeSerialize != null || this.beforeDeserialize != null || this.afterSerialize != null || this.afterDeserialize != null; + } + } + + private readonly MetaType metaType; + + private MethodInfo beforeSerialize; + + private MethodInfo afterSerialize; + + private MethodInfo beforeDeserialize; + + private MethodInfo afterDeserialize; + + internal CallbackSet(MetaType metaType) + { + bool flag = metaType == null; + if (flag) + { + throw new ArgumentNullException("metaType"); + } + this.metaType = metaType; + } + + internal static bool CheckCallbackParameters(TypeModel model, MethodInfo method) + { + ParameterInfo[] parameters = method.GetParameters(); + for (int i = 0; i < parameters.Length; i++) + { + Type parameterType = parameters[i].ParameterType; + bool flag = parameterType == model.MapType(typeof(SerializationContext)); + if (!flag) + { + bool flag2 = parameterType == model.MapType(typeof(Type)); + if (!flag2) + { + return false; + } + } + } + return true; + } + + private MethodInfo SanityCheckCallback(TypeModel model, MethodInfo callback) + { + this.metaType.ThrowIfFrozen(); + bool flag = callback == null; + MethodInfo result; + if (flag) + { + result = callback; + } + else + { + bool isStatic = callback.IsStatic; + if (isStatic) + { + throw new ArgumentException("Callbacks cannot be static", "callback"); + } + bool flag2 = callback.ReturnType != model.MapType(typeof(void)) || !CallbackSet.CheckCallbackParameters(model, callback); + if (flag2) + { + throw CallbackSet.CreateInvalidCallbackSignature(callback); + } + result = callback; + } + return result; + } + + internal static Exception CreateInvalidCallbackSignature(MethodInfo method) + { + return new NotSupportedException("Invalid callback signature in " + method.DeclaringType.FullName + "." + method.Name); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs.meta new file mode 100644 index 00000000..ce94d50b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/CallbackSet.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 7760448d52303f54b8f3541b6ffa032b +timeCreated: 1611403953 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs new file mode 100644 index 00000000..f787bb96 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs @@ -0,0 +1,22 @@ +using System; + +namespace ProtoBuf.Meta +{ + public sealed class LockContentedEventArgs : EventArgs + { + public string OwnerStackTrace + { + get + { + return this.ownerStackTrace; + } + } + + private readonly string ownerStackTrace; + + internal LockContentedEventArgs(string ownerStackTrace) + { + this.ownerStackTrace = ownerStackTrace; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs.meta new file mode 100644 index 00000000..29208e95 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: a2e0f668b28069e42964cccec0290fb9 +timeCreated: 1611404258 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs new file mode 100644 index 00000000..fa01dd00 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs @@ -0,0 +1,6 @@ +using System; + +namespace ProtoBuf.Meta +{ + public delegate void LockContentedEventHandler(object sender, LockContentedEventArgs args); +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs.meta new file mode 100644 index 00000000..abafbdb1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/LockContentedEventHandler.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4bf547271692e3a4db4f971055c6f2a1 +timeCreated: 1611403689 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs new file mode 100644 index 00000000..e65ee2f3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs @@ -0,0 +1,2327 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using System.Text; +using ProtoBuf.Serializers; + +namespace ProtoBuf.Meta +{ + public class MetaType : ISerializerProxy + { + IProtoSerializer ISerializerProxy.Serializer + { + get + { + return this.Serializer; + } + } + + public MetaType BaseType + { + get + { + return this.baseType; + } + } + + internal TypeModel Model + { + get + { + return this.model; + } + } + + public bool IncludeSerializerMethod + { + get + { + return !this.HasFlag(8); + } + set + { + this.SetFlag(8, !value, true); + } + } + + public bool AsReferenceDefault + { + get + { + return this.HasFlag(32); + } + set + { + this.SetFlag(32, value, true); + } + } + + public bool HasCallbacks + { + get + { + return this.callbacks != null && this.callbacks.NonTrivial; + } + } + + public bool HasSubtypes + { + get + { + return this.subTypes != null && this.subTypes.Count != 0; + } + } + + public CallbackSet Callbacks + { + get + { + bool flag = this.callbacks == null; + if (flag) + { + this.callbacks = new CallbackSet(this); + } + return this.callbacks; + } + } + + private bool IsValueType + { + get + { + return this.type.IsValueType; + } + } + + public string Name + { + get + { + return this.name; + } + set + { + this.ThrowIfFrozen(); + this.name = value; + } + } + + public Type Type + { + get + { + return this.type; + } + } + + internal IProtoTypeSerializer Serializer + { + get + { + bool flag = this.serializer == null; + if (flag) + { + int opaqueToken = 0; + try + { + this.model.TakeLock(ref opaqueToken); + bool flag2 = this.serializer == null; + if (flag2) + { + this.SetFlag(4, true, false); + this.serializer = this.BuildSerializer(); + } + } + finally + { + this.model.ReleaseLock(opaqueToken); + } + } + return this.serializer; + } + } + + internal bool IsList + { + get + { + Type type = this.IgnoreListHandling ? null : TypeModel.GetListItemType(this.model, this.type); + return type != null; + } + } + + public bool UseConstructor + { + get + { + return !this.HasFlag(16); + } + set + { + this.SetFlag(16, !value, true); + } + } + + public Type ConstructType + { + get + { + return this.constructType; + } + set + { + this.ThrowIfFrozen(); + this.constructType = value; + } + } + + public ValueMember this[int fieldNumber] + { + get + { + foreach (object obj in this.fields) + { + ValueMember valueMember = (ValueMember)obj; + bool flag = valueMember.FieldNumber == fieldNumber; + if (flag) + { + return valueMember; + } + } + return null; + } + } + + public ValueMember this[MemberInfo member] + { + get + { + bool flag = member == null; + ValueMember result; + if (flag) + { + result = null; + } + else + { + foreach (object obj in this.fields) + { + ValueMember valueMember = (ValueMember)obj; + bool flag2 = valueMember.Member == member; + if (flag2) + { + return valueMember; + } + } + result = null; + } + return result; + } + } + + public bool EnumPassthru + { + get + { + return this.HasFlag(2); + } + set + { + this.SetFlag(2, value, true); + } + } + + public bool IgnoreListHandling + { + get + { + return this.HasFlag(128); + } + set + { + this.SetFlag(128, value, true); + } + } + + internal bool Pending + { + get + { + return this.HasFlag(1); + } + set + { + this.SetFlag(1, value, false); + } + } + + internal IEnumerable Fields + { + get + { + return this.fields; + } + } + + internal bool IsAutoTuple + { + get + { + return this.HasFlag(64); + } + } + + private MetaType baseType; + + private BasicList subTypes; + + internal static readonly Type ienumerable = typeof(IEnumerable); + + private CallbackSet callbacks; + + private string name; + + private MethodInfo factory; + + private readonly RuntimeTypeModel model; + + private readonly Type type; + + private IProtoTypeSerializer serializer; + + private Type constructType; + + private Type surrogate; + + private readonly BasicList fields = new BasicList(); + + private const byte OPTIONS_Pending = 1; + + private const byte OPTIONS_EnumPassThru = 2; + + private const byte OPTIONS_Frozen = 4; + + private const byte OPTIONS_PrivateOnApi = 8; + + private const byte OPTIONS_SkipConstructor = 16; + + private const byte OPTIONS_AsReferenceDefault = 32; + + private const byte OPTIONS_AutoTuple = 64; + + private const byte OPTIONS_IgnoreListHandling = 128; + + private volatile byte flags; + + internal sealed class Comparer : IComparer, IComparer + { + public static readonly MetaType.Comparer Default = new MetaType.Comparer(); + + public int Compare(object x, object y) + { + return this.Compare(x as MetaType, y as MetaType); + } + + public int Compare(MetaType x, MetaType y) + { + bool flag = x == y; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x == null; + if (flag2) + { + result = -1; + } + else + { + bool flag3 = y == null; + if (flag3) + { + result = 1; + } + else + { + result = string.Compare(x.GetSchemaTypeName(), y.GetSchemaTypeName(), StringComparison.Ordinal); + } + } + } + return result; + } + } + + [Flags] + internal enum AttributeFamily + { + None = 0, + ProtoBuf = 1, + DataContractSerialier = 2, + XmlSerializer = 4, + AutoTuple = 8 + } + + public override string ToString() + { + return this.type.ToString(); + } + + private bool IsValidSubType(Type subType) + { + return this.type.IsAssignableFrom(subType); + } + + public MetaType AddSubType(int fieldNumber, Type derivedType) + { + return this.AddSubType(fieldNumber, derivedType, DataFormat.Default); + } + + public MetaType AddSubType(int fieldNumber, Type derivedType, DataFormat dataFormat) + { + bool flag = derivedType == null; + if (flag) + { + throw new ArgumentNullException("derivedType"); + } + bool flag2 = fieldNumber < 1; + if (flag2) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + bool flag3 = (!this.type.IsClass && !this.type.IsInterface) || this.type.IsSealed; + if (flag3) + { + throw new InvalidOperationException("Sub-types can only be added to non-sealed classes"); + } + bool flag4 = !this.IsValidSubType(derivedType); + if (flag4) + { + throw new ArgumentException(derivedType.Name + " is not a valid sub-type of " + this.type.Name, "derivedType"); + } + MetaType metaType = this.model[derivedType]; + this.ThrowIfFrozen(); + metaType.ThrowIfFrozen(); + SubType value = new SubType(fieldNumber, metaType, dataFormat); + this.ThrowIfFrozen(); + metaType.SetBaseType(this); + bool flag5 = this.subTypes == null; + if (flag5) + { + this.subTypes = new BasicList(); + } + this.subTypes.Add(value); + return this; + } + + private void SetBaseType(MetaType baseType) + { + bool flag = baseType == null; + if (flag) + { + throw new ArgumentNullException("baseType"); + } + bool flag2 = this.baseType == baseType; + if (!flag2) + { + bool flag3 = this.baseType != null; + if (flag3) + { + throw new InvalidOperationException("A type can only participate in one inheritance hierarchy"); + } + for (MetaType metaType = baseType; metaType != null; metaType = metaType.baseType) + { + bool flag4 = metaType == this; + if (flag4) + { + throw new InvalidOperationException("Cyclic inheritance is not allowed"); + } + } + this.baseType = baseType; + } + } + + public MetaType SetCallbacks(MethodInfo beforeSerialize, MethodInfo afterSerialize, MethodInfo beforeDeserialize, MethodInfo afterDeserialize) + { + CallbackSet callbackSet = this.Callbacks; + callbackSet.BeforeSerialize = beforeSerialize; + callbackSet.AfterSerialize = afterSerialize; + callbackSet.BeforeDeserialize = beforeDeserialize; + callbackSet.AfterDeserialize = afterDeserialize; + return this; + } + + public MetaType SetCallbacks(string beforeSerialize, string afterSerialize, string beforeDeserialize, string afterDeserialize) + { + bool isValueType = this.IsValueType; + if (isValueType) + { + throw new InvalidOperationException(); + } + CallbackSet callbackSet = this.Callbacks; + callbackSet.BeforeSerialize = this.ResolveMethod(beforeSerialize, true); + callbackSet.AfterSerialize = this.ResolveMethod(afterSerialize, true); + callbackSet.BeforeDeserialize = this.ResolveMethod(beforeDeserialize, true); + callbackSet.AfterDeserialize = this.ResolveMethod(afterDeserialize, true); + return this; + } + + internal string GetSchemaTypeName() + { + bool flag = this.surrogate != null; + string result; + if (flag) + { + result = this.model[this.surrogate].GetSchemaTypeName(); + } + else + { + bool flag2 = !Helpers.IsNullOrEmpty(this.name); + if (flag2) + { + result = this.name; + } + else + { + string text = this.type.Name; + bool isGenericType = this.type.IsGenericType; + if (isGenericType) + { + StringBuilder stringBuilder = new StringBuilder(text); + int num = text.IndexOf('`'); + bool flag3 = num >= 0; + if (flag3) + { + stringBuilder.Length = num; + } + foreach (Type type in this.type.GetGenericArguments()) + { + stringBuilder.Append('_'); + Type type2 = type; + int key = this.model.GetKey(ref type2); + MetaType metaType = null; + bool flag4 = key >= 0 && (metaType = this.model[type2]) != null && metaType.surrogate == null; + if (flag4) + { + stringBuilder.Append(metaType.GetSchemaTypeName()); + } + else + { + stringBuilder.Append(type2.Name); + } + } + result = stringBuilder.ToString(); + } + else + { + result = text; + } + } + } + return result; + } + + public MetaType SetFactory(MethodInfo factory) + { + this.model.VerifyFactory(factory, this.type); + this.ThrowIfFrozen(); + this.factory = factory; + return this; + } + + public MetaType SetFactory(string factory) + { + return this.SetFactory(this.ResolveMethod(factory, false)); + } + + private MethodInfo ResolveMethod(string name, bool instance) + { + bool flag = Helpers.IsNullOrEmpty(name); + MethodInfo result; + if (flag) + { + result = null; + } + else + { + result = (instance ? Helpers.GetInstanceMethod(this.type, name) : Helpers.GetStaticMethod(this.type, name)); + } + return result; + } + + internal static Exception InbuiltType(Type type) + { + return new ArgumentException("Data of this type has inbuilt behaviour, and cannot be added to a model in this way: " + type.FullName); + } + + internal MetaType(RuntimeTypeModel model, Type type, MethodInfo factory) + { + this.factory = factory; + bool flag = model == null; + if (flag) + { + throw new ArgumentNullException("model"); + } + bool flag2 = type == null; + if (flag2) + { + throw new ArgumentNullException("type"); + } + IProtoSerializer protoSerializer = model.TryGetBasicTypeSerializer(type); + bool flag3 = protoSerializer != null; + if (flag3) + { + throw MetaType.InbuiltType(type); + } + this.type = type; + this.model = model; + bool flag4 = Helpers.IsEnum(type); + if (flag4) + { + this.EnumPassthru = type.IsDefined(model.MapType(typeof(FlagsAttribute)), false); + } + } + + protected internal void ThrowIfFrozen() + { + bool flag = (this.flags & 4) > 0; + if (flag) + { + throw new InvalidOperationException("The type cannot be changed once a serializer has been generated for " + this.type.FullName); + } + } + + private IProtoTypeSerializer BuildSerializer() + { + bool flag = Helpers.IsEnum(this.type); + IProtoTypeSerializer result; + if (flag) + { + result = new TagDecorator(1, WireType.Variant, false, new EnumSerializer(this.type, this.GetEnumMap())); + } + else + { + Type type = this.IgnoreListHandling ? null : TypeModel.GetListItemType(this.model, this.type); + bool flag2 = type != null; + if (flag2) + { + bool flag3 = this.surrogate != null; + if (flag3) + { + throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot use a surrogate"); + } + bool flag4 = this.subTypes != null && this.subTypes.Count != 0; + if (flag4) + { + throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be subclassed"); + } + Type defaultType = null; + MetaType.ResolveListTypes(this.model, this.type, ref type, ref defaultType); + ValueMember valueMember = new ValueMember(this.model, 1, this.type, type, defaultType, DataFormat.Default); + result = new TypeSerializer(this.model, this.type, new int[] + { + 1 + }, new IProtoSerializer[] + { + valueMember.Serializer + }, null, true, true, null, this.constructType, this.factory); + } + else + { + bool flag5 = this.surrogate != null; + if (flag5) + { + MetaType metaType = this.model[this.surrogate]; + MetaType metaType2; + while ((metaType2 = metaType.baseType) != null) + { + metaType = metaType2; + } + result = new SurrogateSerializer(this.model, this.type, this.surrogate, metaType.Serializer); + } + else + { + bool isAutoTuple = this.IsAutoTuple; + if (isAutoTuple) + { + MemberInfo[] members; + ConstructorInfo constructorInfo = MetaType.ResolveTupleConstructor(this.type, out members); + bool flag6 = constructorInfo == null; + if (flag6) + { + throw new InvalidOperationException(); + } + result = new TupleSerializer(this.model, constructorInfo, members); + } + else + { + this.fields.Trim(); + int count = this.fields.Count; + int num = (this.subTypes == null) ? 0 : this.subTypes.Count; + int[] array = new int[count + num]; + IProtoSerializer[] array2 = new IProtoSerializer[count + num]; + int num2 = 0; + bool flag7 = num != 0; + if (flag7) + { + foreach (object obj in this.subTypes) + { + SubType subType = (SubType)obj; + bool flag8 = !subType.DerivedType.IgnoreListHandling && this.model.MapType(MetaType.ienumerable).IsAssignableFrom(subType.DerivedType.Type); + if (flag8) + { + throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be used as a subclass"); + } + array[num2] = subType.FieldNumber; + array2[num2++] = subType.Serializer; + } + } + bool flag9 = count != 0; + if (flag9) + { + foreach (object obj2 in this.fields) + { + ValueMember valueMember2 = (ValueMember)obj2; + array[num2] = valueMember2.FieldNumber; + array2[num2++] = valueMember2.Serializer; + } + } + BasicList basicList = null; + for (MetaType metaType3 = this.BaseType; metaType3 != null; metaType3 = metaType3.BaseType) + { + MethodInfo methodInfo = metaType3.HasCallbacks ? metaType3.Callbacks.BeforeDeserialize : null; + bool flag10 = methodInfo != null; + if (flag10) + { + bool flag11 = basicList == null; + if (flag11) + { + basicList = new BasicList(); + } + basicList.Add(methodInfo); + } + } + MethodInfo[] array3 = null; + bool flag12 = basicList != null; + if (flag12) + { + array3 = new MethodInfo[basicList.Count]; + basicList.CopyTo(array3, 0); + Array.Reverse(array3); + } + result = new TypeSerializer(this.model, this.type, array, array2, array3, this.baseType == null, this.UseConstructor, this.callbacks, this.constructType, this.factory); + } + } + } + } + return result; + } + + private static Type GetBaseType(MetaType type) + { + return type.type.BaseType; + } + + internal static bool GetAsReferenceDefault(RuntimeTypeModel model, Type type) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + bool flag2 = Helpers.IsEnum(type); + bool result; + if (flag2) + { + result = false; + } + else + { + AttributeMap[] array = AttributeMap.Create(model, type, false); + for (int i = 0; i < array.Length; i++) + { + bool flag3 = array[i].AttributeType.FullName == "ProtoBuf.ProtoContractAttribute"; + if (flag3) + { + object obj; + bool flag4 = array[i].TryGet("AsReferenceDefault", out obj); + if (flag4) + { + return (bool)obj; + } + } + } + result = false; + } + return result; + } + + internal void ApplyDefaultBehaviour() + { + Type type = MetaType.GetBaseType(this); + bool flag = type != null && this.model.FindWithoutAdd(type) == null && MetaType.GetContractFamily(this.model, type, null) > MetaType.AttributeFamily.None; + if (flag) + { + this.model.FindOrAddAuto(type, true, false, false); + } + AttributeMap[] array = AttributeMap.Create(this.model, this.type, false); + MetaType.AttributeFamily attributeFamily = MetaType.GetContractFamily(this.model, this.type, array); + bool flag2 = attributeFamily == MetaType.AttributeFamily.AutoTuple; + if (flag2) + { + this.SetFlag(64, true, true); + } + bool flag3 = !this.EnumPassthru && Helpers.IsEnum(this.type); + bool flag4 = attributeFamily == MetaType.AttributeFamily.None && !flag3; + if (!flag4) + { + BasicList basicList = null; + BasicList basicList2 = null; + int dataMemberOffset = 0; + int num = 1; + bool flag5 = this.model.InferTagFromNameDefault; + ImplicitFields implicitFields = ImplicitFields.None; + string text = null; + foreach (AttributeMap attributeMap in array) + { + string fullName = attributeMap.AttributeType.FullName; + bool flag6 = !flag3 && fullName == "ProtoBuf.ProtoIncludeAttribute"; + object obj = null; + if (flag6) + { + int fieldNumber = 0; + bool flag7 = attributeMap.TryGet("tag", out obj); + if (flag7) + { + fieldNumber = (int)obj; + } + DataFormat dataFormat = DataFormat.Default; + bool flag8 = attributeMap.TryGet("DataFormat", out obj); + if (flag8) + { + dataFormat = (DataFormat)((int)obj); + } + Type type2 = null; + try + { + bool flag9 = attributeMap.TryGet("knownTypeName", out obj); + if (flag9) + { + type2 = this.model.GetType((string)obj, this.type.Assembly); + } + else + { + bool flag10 = attributeMap.TryGet("knownType", out obj); + if (flag10) + { + type2 = (Type)obj; + } + } + } + catch (Exception innerException) + { + throw new InvalidOperationException("Unable to resolve sub-type of: " + this.type.FullName, innerException); + } + bool flag11 = type2 == null; + if (flag11) + { + throw new InvalidOperationException("Unable to resolve sub-type of: " + this.type.FullName); + } + bool flag12 = this.IsValidSubType(type2); + if (flag12) + { + this.AddSubType(fieldNumber, type2, dataFormat); + } + } + bool flag13 = fullName == "ProtoBuf.ProtoPartialIgnoreAttribute"; + if (flag13) + { + bool flag14 = attributeMap.TryGet("MemberName", out obj) && obj != null; + if (flag14) + { + bool flag15 = basicList == null; + if (flag15) + { + basicList = new BasicList(); + } + basicList.Add((string)obj); + } + } + bool flag16 = !flag3 && fullName == "ProtoBuf.ProtoPartialMemberAttribute"; + if (flag16) + { + bool flag17 = basicList2 == null; + if (flag17) + { + basicList2 = new BasicList(); + } + basicList2.Add(attributeMap); + } + bool flag18 = fullName == "ProtoBuf.ProtoContractAttribute"; + if (flag18) + { + bool flag19 = attributeMap.TryGet("Name", out obj); + if (flag19) + { + text = (string)obj; + } + bool flag20 = Helpers.IsEnum(this.type); + if (flag20) + { + bool flag21 = attributeMap.TryGet("EnumPassthruHasValue", false, out obj) && (bool)obj; + if (flag21) + { + bool flag22 = attributeMap.TryGet("EnumPassthru", out obj); + if (flag22) + { + this.EnumPassthru = (bool)obj; + bool enumPassthru = this.EnumPassthru; + if (enumPassthru) + { + flag3 = false; + } + } + } + } + else + { + bool flag23 = attributeMap.TryGet("DataMemberOffset", out obj); + if (flag23) + { + dataMemberOffset = (int)obj; + } + bool flag24 = attributeMap.TryGet("InferTagFromNameHasValue", false, out obj) && (bool)obj; + if (flag24) + { + bool flag25 = attributeMap.TryGet("InferTagFromName", out obj); + if (flag25) + { + flag5 = (bool)obj; + } + } + bool flag26 = attributeMap.TryGet("ImplicitFields", out obj) && obj != null; + if (flag26) + { + implicitFields = (ImplicitFields)((int)obj); + } + bool flag27 = attributeMap.TryGet("SkipConstructor", out obj); + if (flag27) + { + this.UseConstructor = !(bool)obj; + } + bool flag28 = attributeMap.TryGet("IgnoreListHandling", out obj); + if (flag28) + { + this.IgnoreListHandling = (bool)obj; + } + bool flag29 = attributeMap.TryGet("AsReferenceDefault", out obj); + if (flag29) + { + this.AsReferenceDefault = (bool)obj; + } + bool flag30 = attributeMap.TryGet("ImplicitFirstTag", out obj) && (int)obj > 0; + if (flag30) + { + num = (int)obj; + } + } + } + bool flag31 = fullName == "System.Runtime.Serialization.DataContractAttribute"; + if (flag31) + { + bool flag32 = text == null && attributeMap.TryGet("Name", out obj); + if (flag32) + { + text = (string)obj; + } + } + bool flag33 = fullName == "System.Xml.Serialization.XmlTypeAttribute"; + if (flag33) + { + bool flag34 = text == null && attributeMap.TryGet("TypeName", out obj); + if (flag34) + { + text = (string)obj; + } + } + } + bool flag35 = !Helpers.IsNullOrEmpty(text); + if (flag35) + { + this.Name = text; + } + bool flag36 = implicitFields > ImplicitFields.None; + if (flag36) + { + attributeFamily &= MetaType.AttributeFamily.ProtoBuf; + } + MethodInfo[] array2 = null; + BasicList basicList3 = new BasicList(); + MemberInfo[] members = this.type.GetMembers(flag3 ? (BindingFlags.Static | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)); + foreach (MemberInfo memberInfo in members) + { + bool flag37 = memberInfo.DeclaringType != this.type; + if (!flag37) + { + bool flag38 = !ProtoBuf.Serializer.isSkipProtoIgnore; + if (flag38) + { + bool flag39 = memberInfo.IsDefined(this.model.MapType(typeof(ProtoIgnoreAttribute)), true); + if (flag39) + { + goto IL_756; + } + } + bool flag40 = basicList != null && basicList.Contains(memberInfo.Name); + if (!flag40) + { + bool flag41 = false; + PropertyInfo propertyInfo; + bool flag42 = (propertyInfo = (memberInfo as PropertyInfo)) != null; + if (flag42) + { + bool flag43 = flag3; + if (!flag43) + { + Type type3 = propertyInfo.PropertyType; + bool isPublic = Helpers.GetGetMethod(propertyInfo, false, false) != null; + bool isField = false; + MetaType.ApplyDefaultBehaviour_AddMembers(this.model, attributeFamily, flag3, basicList2, dataMemberOffset, flag5, implicitFields, basicList3, memberInfo, ref flag41, isPublic, isField, ref type3); + } + } + else + { + FieldInfo fieldInfo; + bool flag44 = (fieldInfo = (memberInfo as FieldInfo)) != null; + if (flag44) + { + Type type3 = fieldInfo.FieldType; + bool isPublic = fieldInfo.IsPublic; + bool isField = true; + bool flag45 = flag3 && !fieldInfo.IsStatic; + if (!flag45) + { + MetaType.ApplyDefaultBehaviour_AddMembers(this.model, attributeFamily, flag3, basicList2, dataMemberOffset, flag5, implicitFields, basicList3, memberInfo, ref flag41, isPublic, isField, ref type3); + } + } + else + { + MethodInfo methodInfo; + bool flag46 = (methodInfo = (memberInfo as MethodInfo)) != null; + if (flag46) + { + bool flag47 = flag3; + if (!flag47) + { + AttributeMap[] array4 = AttributeMap.Create(this.model, methodInfo, false); + bool flag48 = array4 != null && array4.Length != 0; + if (flag48) + { + MetaType.CheckForCallback(methodInfo, array4, "ProtoBuf.ProtoBeforeSerializationAttribute", ref array2, 0); + MetaType.CheckForCallback(methodInfo, array4, "ProtoBuf.ProtoAfterSerializationAttribute", ref array2, 1); + MetaType.CheckForCallback(methodInfo, array4, "ProtoBuf.ProtoBeforeDeserializationAttribute", ref array2, 2); + MetaType.CheckForCallback(methodInfo, array4, "ProtoBuf.ProtoAfterDeserializationAttribute", ref array2, 3); + MetaType.CheckForCallback(methodInfo, array4, "System.Runtime.Serialization.OnSerializingAttribute", ref array2, 4); + MetaType.CheckForCallback(methodInfo, array4, "System.Runtime.Serialization.OnSerializedAttribute", ref array2, 5); + MetaType.CheckForCallback(methodInfo, array4, "System.Runtime.Serialization.OnDeserializingAttribute", ref array2, 6); + MetaType.CheckForCallback(methodInfo, array4, "System.Runtime.Serialization.OnDeserializedAttribute", ref array2, 7); + } + } + } + } + } + } + } + IL_756:; + } + ProtoMemberAttribute[] array5 = new ProtoMemberAttribute[basicList3.Count]; + basicList3.CopyTo(array5, 0); + bool flag49 = flag5 || implicitFields > ImplicitFields.None; + if (flag49) + { + Array.Sort(array5); + int num2 = num; + foreach (ProtoMemberAttribute protoMemberAttribute in array5) + { + bool flag50 = !protoMemberAttribute.TagIsPinned; + if (flag50) + { + protoMemberAttribute.Rebase(num2++); + } + } + } + foreach (ProtoMemberAttribute normalizedAttribute in array5) + { + ValueMember valueMember = this.ApplyDefaultBehaviour(flag3, normalizedAttribute); + bool flag51 = valueMember != null; + if (flag51) + { + this.Add(valueMember); + } + } + bool flag52 = array2 != null; + if (flag52) + { + this.SetCallbacks(MetaType.Coalesce(array2, 0, 4), MetaType.Coalesce(array2, 1, 5), MetaType.Coalesce(array2, 2, 6), MetaType.Coalesce(array2, 3, 7)); + } + } + } + + private static void ApplyDefaultBehaviour_AddMembers(TypeModel model, MetaType.AttributeFamily family, bool isEnum, BasicList partialMembers, int dataMemberOffset, bool inferTagByName, ImplicitFields implicitMode, BasicList members, MemberInfo member, ref bool forced, bool isPublic, bool isField, ref Type effectiveType) + { + if (implicitMode != ImplicitFields.AllPublic) + { + if (implicitMode == ImplicitFields.AllFields) + { + if (isField) + { + forced = true; + } + } + } + else if (isPublic) + { + forced = true; + } + bool flag = effectiveType.IsSubclassOf(model.MapType(typeof(Delegate))); + if (flag) + { + effectiveType = null; + } + bool flag2 = effectiveType != null; + if (flag2) + { + ProtoMemberAttribute protoMemberAttribute = MetaType.NormalizeProtoMember(model, member, family, forced, isEnum, partialMembers, dataMemberOffset, inferTagByName); + bool flag3 = protoMemberAttribute != null; + if (flag3) + { + members.Add(protoMemberAttribute); + } + } + } + + private static MethodInfo Coalesce(MethodInfo[] arr, int x, int y) + { + MethodInfo methodInfo = arr[x]; + bool flag = methodInfo == null; + if (flag) + { + methodInfo = arr[y]; + } + return methodInfo; + } + + internal static MetaType.AttributeFamily GetContractFamily(RuntimeTypeModel model, Type type, AttributeMap[] attributes) + { + MetaType.AttributeFamily attributeFamily = MetaType.AttributeFamily.None; + bool flag = attributes == null; + if (flag) + { + attributes = AttributeMap.Create(model, type, false); + } + for (int i = 0; i < attributes.Length; i++) + { + string fullName = attributes[i].AttributeType.FullName; + if (!(fullName == "ProtoBuf.ProtoContractAttribute")) + { + if (!(fullName == "System.Xml.Serialization.XmlTypeAttribute")) + { + if (fullName == "System.Runtime.Serialization.DataContractAttribute") + { + bool flag2 = !model.AutoAddProtoContractTypesOnly; + if (flag2) + { + attributeFamily |= MetaType.AttributeFamily.DataContractSerialier; + } + } + } + else + { + bool flag3 = !model.AutoAddProtoContractTypesOnly; + if (flag3) + { + attributeFamily |= MetaType.AttributeFamily.XmlSerializer; + } + } + } + else + { + bool flag4 = false; + MetaType.GetFieldBoolean(ref flag4, attributes[i], "UseProtoMembersOnly"); + bool flag5 = flag4; + if (flag5) + { + return MetaType.AttributeFamily.ProtoBuf; + } + attributeFamily |= MetaType.AttributeFamily.ProtoBuf; + } + } + bool flag6 = attributeFamily == MetaType.AttributeFamily.None; + if (flag6) + { + MemberInfo[] array; + bool flag7 = MetaType.ResolveTupleConstructor(type, out array) != null; + if (flag7) + { + attributeFamily |= MetaType.AttributeFamily.AutoTuple; + } + } + return attributeFamily; + } + + internal static ConstructorInfo ResolveTupleConstructor(Type type, out MemberInfo[] mappedMembers) + { + mappedMembers = null; + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + bool isAbstract = type.IsAbstract; + ConstructorInfo result; + if (isAbstract) + { + result = null; + } + else + { + ConstructorInfo[] constructors = Helpers.GetConstructors(type, false); + bool flag2 = constructors.Length == 0 || (constructors.Length == 1 && constructors[0].GetParameters().Length == 0); + if (flag2) + { + result = null; + } + else + { + MemberInfo[] instanceFieldsAndProperties = Helpers.GetInstanceFieldsAndProperties(type, true); + BasicList basicList = new BasicList(); + for (int i = 0; i < instanceFieldsAndProperties.Length; i++) + { + PropertyInfo propertyInfo = instanceFieldsAndProperties[i] as PropertyInfo; + bool flag3 = propertyInfo != null; + if (flag3) + { + bool flag4 = !propertyInfo.CanRead; + if (flag4) + { + return null; + } + bool flag5 = propertyInfo.CanWrite && Helpers.GetSetMethod(propertyInfo, false, false) != null; + if (flag5) + { + return null; + } + basicList.Add(propertyInfo); + } + else + { + FieldInfo fieldInfo = instanceFieldsAndProperties[i] as FieldInfo; + bool flag6 = fieldInfo != null; + if (flag6) + { + bool flag7 = !fieldInfo.IsInitOnly; + if (flag7) + { + return null; + } + basicList.Add(fieldInfo); + } + } + } + bool flag8 = basicList.Count == 0; + if (flag8) + { + result = null; + } + else + { + MemberInfo[] array = new MemberInfo[basicList.Count]; + basicList.CopyTo(array, 0); + int[] array2 = new int[array.Length]; + int num = 0; + ConstructorInfo constructorInfo = null; + mappedMembers = new MemberInfo[array2.Length]; + for (int j = 0; j < constructors.Length; j++) + { + ParameterInfo[] parameters = constructors[j].GetParameters(); + bool flag9 = parameters.Length != array.Length; + if (!flag9) + { + for (int k = 0; k < array2.Length; k++) + { + array2[k] = -1; + } + for (int l = 0; l < parameters.Length; l++) + { + string b = parameters[l].Name.ToLower(); + for (int m = 0; m < array.Length; m++) + { + bool flag10 = array[m].Name.ToLower() != b; + if (!flag10) + { + Type memberType = Helpers.GetMemberType(array[m]); + bool flag11 = memberType != parameters[l].ParameterType; + if (!flag11) + { + array2[l] = m; + } + } + } + } + bool flag12 = false; + for (int n = 0; n < array2.Length; n++) + { + bool flag13 = array2[n] < 0; + if (flag13) + { + flag12 = true; + break; + } + mappedMembers[n] = array[array2[n]]; + } + bool flag14 = flag12; + if (!flag14) + { + num++; + constructorInfo = constructors[j]; + } + } + } + result = ((num == 1) ? constructorInfo : null); + } + } + } + return result; + } + + private static void CheckForCallback(MethodInfo method, AttributeMap[] attributes, string callbackTypeName, ref MethodInfo[] callbacks, int index) + { + for (int i = 0; i < attributes.Length; i++) + { + bool flag = attributes[i].AttributeType.FullName == callbackTypeName; + if (flag) + { + bool flag2 = callbacks == null; + if (flag2) + { + callbacks = new MethodInfo[8]; + } + else + { + bool flag3 = callbacks[index] != null; + if (flag3) + { + Type reflectedType = method.ReflectedType; + throw new ProtoException("Duplicate " + callbackTypeName + " callbacks on " + reflectedType.FullName); + } + } + callbacks[index] = method; + } + } + } + + private static bool HasFamily(MetaType.AttributeFamily value, MetaType.AttributeFamily required) + { + return (value & required) == required; + } + + private static ProtoMemberAttribute NormalizeProtoMember(TypeModel model, MemberInfo member, MetaType.AttributeFamily family, bool forced, bool isEnum, BasicList partialMembers, int dataMemberOffset, bool inferByTagName) + { + bool flag = member == null || (family == MetaType.AttributeFamily.None && !isEnum); + ProtoMemberAttribute result; + if (flag) + { + result = null; + } + else + { + int num = int.MinValue; + int num2 = inferByTagName ? -1 : 1; + string text = null; + bool isPacked = false; + bool flag2 = false; + bool flag3 = false; + bool isRequired = false; + bool asReference = false; + bool flag4 = false; + bool dynamicType = false; + bool tagIsPinned = false; + bool overwriteList = false; + DataFormat dataFormat = DataFormat.Default; + if (isEnum) + { + forced = true; + } + AttributeMap[] attribs = AttributeMap.Create(model, member, true); + if (isEnum) + { + AttributeMap attribute = MetaType.GetAttribute(attribs, "ProtoBuf.ProtoIgnoreAttribute"); + bool flag5 = attribute != null; + if (flag5) + { + flag2 = true; + } + else + { + attribute = MetaType.GetAttribute(attribs, "ProtoBuf.ProtoEnumAttribute"); + num = Convert.ToInt32(((FieldInfo)member).GetRawConstantValue()); + bool flag6 = attribute != null; + if (flag6) + { + MetaType.GetFieldName(ref text, attribute, "Name"); + bool flag7 = (bool)Helpers.GetInstanceMethod(attribute.AttributeType, "HasValue").Invoke(attribute.Target, null); + if (flag7) + { + object obj; + bool flag8 = attribute.TryGet("Value", out obj); + if (flag8) + { + num = (int)obj; + } + } + } + } + flag3 = true; + } + bool flag9 = !flag2 && !flag3; + if (flag9) + { + AttributeMap attribute = MetaType.GetAttribute(attribs, "ProtoBuf.ProtoMemberAttribute"); + MetaType.GetIgnore(ref flag2, attribute, attribs, "ProtoBuf.ProtoIgnoreAttribute"); + bool flag10 = !flag2 && attribute != null; + if (flag10) + { + MetaType.GetFieldNumber(ref num, attribute, "Tag"); + MetaType.GetFieldName(ref text, attribute, "Name"); + MetaType.GetFieldBoolean(ref isRequired, attribute, "IsRequired"); + MetaType.GetFieldBoolean(ref isPacked, attribute, "IsPacked"); + MetaType.GetFieldBoolean(ref overwriteList, attribute, "OverwriteList"); + MetaType.GetDataFormat(ref dataFormat, attribute, "DataFormat"); + MetaType.GetFieldBoolean(ref flag4, attribute, "AsReferenceHasValue", false); + bool flag11 = flag4; + if (flag11) + { + flag4 = MetaType.GetFieldBoolean(ref asReference, attribute, "AsReference", true); + } + MetaType.GetFieldBoolean(ref dynamicType, attribute, "DynamicType"); + tagIsPinned = (flag3 = (num > 0)); + } + bool flag12 = !flag3 && partialMembers != null; + if (flag12) + { + foreach (object obj2 in partialMembers) + { + AttributeMap attributeMap = (AttributeMap)obj2; + object obj3; + bool flag13 = attributeMap.TryGet("MemberName", out obj3) && (string)obj3 == member.Name; + if (flag13) + { + MetaType.GetFieldNumber(ref num, attributeMap, "Tag"); + MetaType.GetFieldName(ref text, attributeMap, "Name"); + MetaType.GetFieldBoolean(ref isRequired, attributeMap, "IsRequired"); + MetaType.GetFieldBoolean(ref isPacked, attributeMap, "IsPacked"); + MetaType.GetFieldBoolean(ref overwriteList, attribute, "OverwriteList"); + MetaType.GetDataFormat(ref dataFormat, attributeMap, "DataFormat"); + MetaType.GetFieldBoolean(ref flag4, attribute, "AsReferenceHasValue", false); + bool flag14 = flag4; + if (flag14) + { + flag4 = MetaType.GetFieldBoolean(ref asReference, attributeMap, "AsReference", true); + } + MetaType.GetFieldBoolean(ref dynamicType, attributeMap, "DynamicType"); + bool flag15; + flag3 = (flag15 = (tagIsPinned = (num > 0))); + if (flag15) + { + break; + } + } + } + } + } + bool flag16 = !flag2 && !flag3 && MetaType.HasFamily(family, MetaType.AttributeFamily.DataContractSerialier); + if (flag16) + { + AttributeMap attribute = MetaType.GetAttribute(attribs, "System.Runtime.Serialization.DataMemberAttribute"); + bool flag17 = attribute != null; + if (flag17) + { + MetaType.GetFieldNumber(ref num, attribute, "Order"); + MetaType.GetFieldName(ref text, attribute, "Name"); + MetaType.GetFieldBoolean(ref isRequired, attribute, "IsRequired"); + flag3 = (num >= num2); + bool flag18 = flag3; + if (flag18) + { + num += dataMemberOffset; + } + } + } + bool flag19 = !flag2 && !flag3 && MetaType.HasFamily(family, MetaType.AttributeFamily.XmlSerializer); + if (flag19) + { + AttributeMap attribute = MetaType.GetAttribute(attribs, "System.Xml.Serialization.XmlElementAttribute"); + bool flag20 = attribute == null; + if (flag20) + { + attribute = MetaType.GetAttribute(attribs, "System.Xml.Serialization.XmlArrayAttribute"); + } + MetaType.GetIgnore(ref flag2, attribute, attribs, "System.Xml.Serialization.XmlIgnoreAttribute"); + bool flag21 = attribute != null && !flag2; + if (flag21) + { + MetaType.GetFieldNumber(ref num, attribute, "Order"); + MetaType.GetFieldName(ref text, attribute, "ElementName"); + flag3 = (num >= num2); + } + } + bool flag22 = !flag2 && !flag3; + if (flag22) + { + bool flag23 = MetaType.GetAttribute(attribs, "System.NonSerializedAttribute") != null; + if (flag23) + { + flag2 = true; + } + } + bool flag24 = flag2 || (num < num2 && !forced); + if (flag24) + { + result = null; + } + else + { + result = new ProtoMemberAttribute(num, forced || inferByTagName) + { + AsReference = asReference, + AsReferenceHasValue = flag4, + DataFormat = dataFormat, + DynamicType = dynamicType, + IsPacked = isPacked, + OverwriteList = overwriteList, + IsRequired = isRequired, + Name = (Helpers.IsNullOrEmpty(text) ? member.Name : text), + Member = member, + TagIsPinned = tagIsPinned + }; + } + } + return result; + } + + private ValueMember ApplyDefaultBehaviour(bool isEnum, ProtoMemberAttribute normalizedAttribute) + { + MemberInfo member= null; + bool flag = normalizedAttribute == null || (member = normalizedAttribute.Member) == null; + ValueMember result; + if (flag) + { + result = null; + } + else + { + Type memberType = Helpers.GetMemberType(member); + Type type = null; + Type defaultType = null; + MetaType.ResolveListTypes(this.model, memberType, ref type, ref defaultType); + bool flag2 = type != null; + if (flag2) + { + int num = this.model.FindOrAddAuto(memberType, false, true, false); + bool flag3 = num >= 0 && this.model[memberType].IgnoreListHandling; + if (flag3) + { + type = null; + defaultType = null; + } + } + AttributeMap[] attribs = AttributeMap.Create(this.model, member, true); + object defaultValue = null; + bool useImplicitZeroDefaults = this.model.UseImplicitZeroDefaults; + if (useImplicitZeroDefaults) + { + ProtoTypeCode typeCode = Helpers.GetTypeCode(memberType); + switch (typeCode) + { + case ProtoTypeCode.Boolean: + defaultValue = false; + break; + case ProtoTypeCode.Char: + defaultValue = '\0'; + break; + case ProtoTypeCode.SByte: + defaultValue = 0; + break; + case ProtoTypeCode.Byte: + defaultValue = 0; + break; + case ProtoTypeCode.Int16: + defaultValue = 0; + break; + case ProtoTypeCode.UInt16: + defaultValue = 0; + break; + case ProtoTypeCode.Int32: + defaultValue = 0; + break; + case ProtoTypeCode.UInt32: + defaultValue = 0u; + break; + case ProtoTypeCode.Int64: + defaultValue = 0L; + break; + case ProtoTypeCode.UInt64: + defaultValue = 0UL; + break; + case ProtoTypeCode.Single: + defaultValue = 0f; + break; + case ProtoTypeCode.Double: + defaultValue = 0.0; + break; + case ProtoTypeCode.Decimal: + defaultValue = 0m; + break; + default: + if (typeCode != ProtoTypeCode.TimeSpan) + { + if (typeCode == ProtoTypeCode.Guid) + { + defaultValue = Guid.Empty; + } + } + else + { + defaultValue = TimeSpan.Zero; + } + break; + } + } + AttributeMap attribute; + bool flag4 = (attribute = MetaType.GetAttribute(attribs, "System.ComponentModel.DefaultValueAttribute")) != null; + if (flag4) + { + object obj; + bool flag5 = attribute.TryGet("Value", out obj); + if (flag5) + { + defaultValue = obj; + } + } + ValueMember valueMember = (isEnum || normalizedAttribute.Tag > 0) ? new ValueMember(this.model, this.type, normalizedAttribute.Tag, member, memberType, type, defaultType, normalizedAttribute.DataFormat, defaultValue) : null; + bool flag6 = valueMember != null; + if (flag6) + { + Type declaringType = this.type; + PropertyInfo propertyInfo = Helpers.GetProperty(declaringType, member.Name + "Specified", true); + MethodInfo getMethod = Helpers.GetGetMethod(propertyInfo, true, true); + bool flag7 = getMethod == null || getMethod.IsStatic; + if (flag7) + { + propertyInfo = null; + } + bool flag8 = propertyInfo != null; + if (flag8) + { + valueMember.SetSpecified(getMethod, Helpers.GetSetMethod(propertyInfo, true, true)); + } + else + { + MethodInfo instanceMethod = Helpers.GetInstanceMethod(declaringType, "ShouldSerialize" + member.Name, Helpers.EmptyTypes); + bool flag9 = instanceMethod != null && instanceMethod.ReturnType == this.model.MapType(typeof(bool)); + if (flag9) + { + valueMember.SetSpecified(instanceMethod, null); + } + } + bool flag10 = !Helpers.IsNullOrEmpty(normalizedAttribute.Name); + if (flag10) + { + valueMember.SetName(normalizedAttribute.Name); + } + valueMember.IsPacked = normalizedAttribute.IsPacked; + valueMember.IsRequired = normalizedAttribute.IsRequired; + valueMember.OverwriteList = normalizedAttribute.OverwriteList; + bool asReferenceHasValue = normalizedAttribute.AsReferenceHasValue; + if (asReferenceHasValue) + { + valueMember.AsReference = normalizedAttribute.AsReference; + } + valueMember.DynamicType = normalizedAttribute.DynamicType; + } + result = valueMember; + } + return result; + } + + private static void GetDataFormat(ref DataFormat value, AttributeMap attrib, string memberName) + { + bool flag = attrib == null || value > DataFormat.Default; + if (!flag) + { + object obj; + bool flag2 = attrib.TryGet(memberName, out obj) && obj != null; + if (flag2) + { + value = (DataFormat)obj; + } + } + } + + private static void GetIgnore(ref bool ignore, AttributeMap attrib, AttributeMap[] attribs, string fullName) + { + bool flag = ignore || attrib == null; + if (!flag) + { + ignore = (MetaType.GetAttribute(attribs, fullName) != null); + } + } + + private static void GetFieldBoolean(ref bool value, AttributeMap attrib, string memberName) + { + MetaType.GetFieldBoolean(ref value, attrib, memberName, true); + } + + private static bool GetFieldBoolean(ref bool value, AttributeMap attrib, string memberName, bool publicOnly) + { + bool flag = attrib == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = value; + if (flag2) + { + result = true; + } + else + { + object obj; + bool flag3 = attrib.TryGet(memberName, publicOnly, out obj) && obj != null; + if (flag3) + { + value = (bool)obj; + result = true; + } + else + { + result = false; + } + } + } + return result; + } + + private static void GetFieldNumber(ref int value, AttributeMap attrib, string memberName) + { + bool flag = attrib == null || value > 0; + if (!flag) + { + object obj; + bool flag2 = attrib.TryGet(memberName, out obj) && obj != null; + if (flag2) + { + value = (int)obj; + } + } + } + + private static void GetFieldName(ref string name, AttributeMap attrib, string memberName) + { + bool flag = attrib == null || !Helpers.IsNullOrEmpty(name); + if (!flag) + { + object obj; + bool flag2 = attrib.TryGet(memberName, out obj) && obj != null; + if (flag2) + { + name = (string)obj; + } + } + } + + private static AttributeMap GetAttribute(AttributeMap[] attribs, string fullName) + { + foreach (AttributeMap attributeMap in attribs) + { + bool flag = attributeMap != null && attributeMap.AttributeType.FullName == fullName; + if (flag) + { + return attributeMap; + } + } + return null; + } + + public MetaType Add(int fieldNumber, string memberName) + { + this.AddField(fieldNumber, memberName, null, null, null); + return this; + } + + public ValueMember AddField(int fieldNumber, string memberName) + { + return this.AddField(fieldNumber, memberName, null, null, null); + } + + public MetaType Add(string memberName) + { + this.Add(this.GetNextFieldNumber(), memberName); + return this; + } + + public void SetSurrogate(Type surrogateType) + { + bool flag = surrogateType == this.type; + if (flag) + { + surrogateType = null; + } + bool flag2 = surrogateType != null; + if (flag2) + { + bool flag3 = surrogateType != null && Helpers.IsAssignableFrom(this.model.MapType(typeof(IEnumerable)), surrogateType); + if (flag3) + { + throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be used as a surrogate"); + } + } + this.ThrowIfFrozen(); + this.surrogate = surrogateType; + } + + internal MetaType GetSurrogateOrSelf() + { + bool flag = this.surrogate != null; + MetaType result; + if (flag) + { + result = this.model[this.surrogate]; + } + else + { + result = this; + } + return result; + } + + internal MetaType GetSurrogateOrBaseOrSelf(bool deep) + { + bool flag = this.surrogate != null; + MetaType result; + if (flag) + { + result = this.model[this.surrogate]; + } + else + { + MetaType metaType = this.baseType; + bool flag2 = metaType != null; + if (flag2) + { + if (deep) + { + MetaType metaType2; + do + { + metaType2 = metaType; + metaType = metaType.baseType; + } + while (metaType != null); + result = metaType2; + } + else + { + result = metaType; + } + } + else + { + result = this; + } + } + return result; + } + + private int GetNextFieldNumber() + { + int num = 0; + foreach (object obj in this.fields) + { + ValueMember valueMember = (ValueMember)obj; + bool flag = valueMember.FieldNumber > num; + if (flag) + { + num = valueMember.FieldNumber; + } + } + bool flag2 = this.subTypes != null; + if (flag2) + { + foreach (object obj2 in this.subTypes) + { + SubType subType = (SubType)obj2; + bool flag3 = subType.FieldNumber > num; + if (flag3) + { + num = subType.FieldNumber; + } + } + } + return num + 1; + } + + public MetaType Add(params string[] memberNames) + { + bool flag = memberNames == null; + if (flag) + { + throw new ArgumentNullException("memberNames"); + } + int nextFieldNumber = this.GetNextFieldNumber(); + for (int i = 0; i < memberNames.Length; i++) + { + this.Add(nextFieldNumber++, memberNames[i]); + } + return this; + } + + public MetaType Add(int fieldNumber, string memberName, object defaultValue) + { + this.AddField(fieldNumber, memberName, null, null, defaultValue); + return this; + } + + public MetaType Add(int fieldNumber, string memberName, Type itemType, Type defaultType) + { + this.AddField(fieldNumber, memberName, itemType, defaultType, null); + return this; + } + + public ValueMember AddField(int fieldNumber, string memberName, Type itemType, Type defaultType) + { + return this.AddField(fieldNumber, memberName, itemType, defaultType, null); + } + + private ValueMember AddField(int fieldNumber, string memberName, Type itemType, Type defaultType, object defaultValue) + { + MemberInfo memberInfo = null; + MemberInfo[] member = this.type.GetMember(memberName, Helpers.IsEnum(this.type) ? (BindingFlags.Static | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)); + bool flag = member != null && member.Length == 1; + if (flag) + { + memberInfo = member[0]; + } + bool flag2 = memberInfo == null; + if (flag2) + { + throw new ArgumentException("Unable to determine member: " + memberName, "memberName"); + } + MemberTypes memberType = memberInfo.MemberType; + Type memberType2; + if (memberType != MemberTypes.Field) + { + if (memberType != MemberTypes.Property) + { + throw new NotSupportedException(memberInfo.MemberType.ToString()); + } + memberType2 = ((PropertyInfo)memberInfo).PropertyType; + } + else + { + memberType2 = ((FieldInfo)memberInfo).FieldType; + } + MetaType.ResolveListTypes(this.model, memberType2, ref itemType, ref defaultType); + ValueMember valueMember = new ValueMember(this.model, this.type, fieldNumber, memberInfo, memberType2, itemType, defaultType, DataFormat.Default, defaultValue); + this.Add(valueMember); + return valueMember; + } + + internal static void ResolveListTypes(TypeModel model, Type type, ref Type itemType, ref Type defaultType) + { + bool flag = type == null; + if (!flag) + { + bool isArray = type.IsArray; + if (isArray) + { + bool flag2 = type.GetArrayRank() != 1; + if (flag2) + { + throw new NotSupportedException("Multi-dimension arrays are supported"); + } + itemType = type.GetElementType(); + bool flag3 = itemType == model.MapType(typeof(byte)); + if (flag3) + { + Type type2; + itemType = (type2 = null); + defaultType = type2; + } + else + { + defaultType = type; + } + } + bool flag4 = itemType == null; + if (flag4) + { + itemType = TypeModel.GetListItemType(model, type); + } + bool flag5 = itemType != null; + if (flag5) + { + Type type3 = null; + Type type4 = null; + MetaType.ResolveListTypes(model, itemType, ref type3, ref type4); + bool flag6 = type3 != null; + if (flag6) + { + throw TypeModel.CreateNestedListsNotSupported(); + } + } + bool flag7 = itemType != null && defaultType == null; + if (flag7) + { + bool flag8 = type.IsClass && !type.IsAbstract && Helpers.GetConstructor(type, Helpers.EmptyTypes, true) != null; + if (flag8) + { + defaultType = type; + } + bool flag9 = defaultType == null; + if (flag9) + { + bool isInterface = type.IsInterface; + if (isInterface) + { + Type[] genericArguments = null; + bool flag10 = type.IsGenericType && type.GetGenericTypeDefinition() == model.MapType(typeof(IDictionary<, >)) && itemType == model.MapType(typeof(KeyValuePair<, >)).MakeGenericType(genericArguments = type.GetGenericArguments()); + if (flag10) + { + defaultType = model.MapType(typeof(Dictionary<, >)).MakeGenericType(genericArguments); + } + else + { + defaultType = model.MapType(typeof(List<>)).MakeGenericType(new Type[] + { + itemType + }); + } + } + } + bool flag11 = defaultType != null && !Helpers.IsAssignableFrom(type, defaultType); + if (flag11) + { + defaultType = null; + } + } + } + } + + private void Add(ValueMember member) + { + int opaqueToken = 0; + try + { + this.model.TakeLock(ref opaqueToken); + this.ThrowIfFrozen(); + this.fields.Add(member); + } + finally + { + this.model.ReleaseLock(opaqueToken); + } + } + + public ValueMember[] GetFields() + { + ValueMember[] array = new ValueMember[this.fields.Count]; + this.fields.CopyTo(array, 0); + Array.Sort(array, ValueMember.Comparer.Default); + return array; + } + + public SubType[] GetSubtypes() + { + bool flag = this.subTypes == null || this.subTypes.Count == 0; + SubType[] result; + if (flag) + { + result = new SubType[0]; + } + else + { + SubType[] array = new SubType[this.subTypes.Count]; + this.subTypes.CopyTo(array, 0); + Array.Sort(array, SubType.Comparer.Default); + result = array; + } + return result; + } + + internal bool IsDefined(int fieldNumber) + { + foreach (object obj in this.fields) + { + ValueMember valueMember = (ValueMember)obj; + bool flag = valueMember.FieldNumber == fieldNumber; + if (flag) + { + return true; + } + } + return false; + } + + internal int GetKey(bool demand, bool getBaseKey) + { + return this.model.GetKey(this.type, demand, getBaseKey); + } + + internal EnumSerializer.EnumPair[] GetEnumMap() + { + bool flag = this.HasFlag(2); + EnumSerializer.EnumPair[] result; + if (flag) + { + result = null; + } + else + { + EnumSerializer.EnumPair[] array = new EnumSerializer.EnumPair[this.fields.Count]; + for (int i = 0; i < array.Length; i++) + { + ValueMember valueMember = (ValueMember)this.fields[i]; + int fieldNumber = valueMember.FieldNumber; + object rawEnumValue = valueMember.GetRawEnumValue(); + array[i] = new EnumSerializer.EnumPair(fieldNumber, rawEnumValue, valueMember.MemberType); + } + result = array; + } + return result; + } + + private bool HasFlag(byte flag) + { + return (this.flags & flag) == flag; + } + + private void SetFlag(byte flag, bool value, bool throwIfFrozen) + { + bool flag2 = throwIfFrozen && this.HasFlag(flag) != value; + if (flag2) + { + this.ThrowIfFrozen(); + } + if (value) + { + this.flags |= flag; + } + else + { + this.flags &= (byte)~flag; + } + } + + internal static MetaType GetRootType(MetaType source) + { + MetaType result; + while (source.serializer != null) + { + MetaType metaType = source.baseType; + bool flag = metaType == null; + if (flag) + { + result = source; + return result; + } + source = metaType; + } + RuntimeTypeModel runtimeTypeModel = source.model; + int opaqueToken = 0; + try + { + runtimeTypeModel.TakeLock(ref opaqueToken); + MetaType metaType2; + while ((metaType2 = source.baseType) != null) + { + source = metaType2; + } + result = source; + } + finally + { + runtimeTypeModel.ReleaseLock(opaqueToken); + } + return result; + } + + internal bool IsPrepared() + { + return false; + } + + internal static StringBuilder NewLine(StringBuilder builder, int indent) + { + return Helpers.AppendLine(builder).Append(' ', indent * 3); + } + + internal void WriteSchema(StringBuilder builder, int indent, ref bool requiresBclImport) + { + bool flag = this.surrogate != null; + if (!flag) + { + ValueMember[] array = new ValueMember[this.fields.Count]; + this.fields.CopyTo(array, 0); + Array.Sort(array, ValueMember.Comparer.Default); + bool isList = this.IsList; + if (isList) + { + string schemaTypeName = this.model.GetSchemaTypeName(TypeModel.GetListItemType(this.model, this.type), DataFormat.Default, false, false, ref requiresBclImport); + MetaType.NewLine(builder, indent).Append("message ").Append(this.GetSchemaTypeName()).Append(" {"); + MetaType.NewLine(builder, indent + 1).Append("repeated ").Append(schemaTypeName).Append(" items = 1;"); + MetaType.NewLine(builder, indent).Append('}'); + } + else + { + bool isAutoTuple = this.IsAutoTuple; + if (isAutoTuple) + { + MemberInfo[] array2; + bool flag2 = MetaType.ResolveTupleConstructor(this.type, out array2) != null; + if (flag2) + { + MetaType.NewLine(builder, indent).Append("message ").Append(this.GetSchemaTypeName()).Append(" {"); + for (int i = 0; i < array2.Length; i++) + { + bool flag3 = array2[i] is PropertyInfo; + Type effectiveType; + if (flag3) + { + effectiveType = ((PropertyInfo)array2[i]).PropertyType; + } + else + { + bool flag4 = array2[i] is FieldInfo; + if (!flag4) + { + throw new NotSupportedException("Unknown member type: " + array2[i].GetType().Name); + } + effectiveType = ((FieldInfo)array2[i]).FieldType; + } + MetaType.NewLine(builder, indent + 1).Append("optional ").Append(this.model.GetSchemaTypeName(effectiveType, DataFormat.Default, false, false, ref requiresBclImport).Replace('.', '_')).Append(' ').Append(array2[i].Name).Append(" = ").Append(i + 1).Append(';'); + } + MetaType.NewLine(builder, indent).Append('}'); + } + } + else + { + bool flag5 = Helpers.IsEnum(this.type); + if (flag5) + { + MetaType.NewLine(builder, indent).Append("enum ").Append(this.GetSchemaTypeName()).Append(" {"); + bool flag6 = array.Length == 0 && this.EnumPassthru; + if (flag6) + { + bool flag7 = this.type.IsDefined(this.model.MapType(typeof(FlagsAttribute)), false); + if (flag7) + { + MetaType.NewLine(builder, indent + 1).Append("// this is a composite/flags enumeration"); + } + else + { + MetaType.NewLine(builder, indent + 1).Append("// this enumeration will be passed as a raw value"); + } + foreach (FieldInfo fieldInfo in this.type.GetFields()) + { + bool flag8 = fieldInfo.IsStatic && fieldInfo.IsLiteral; + if (flag8) + { + object rawConstantValue = fieldInfo.GetRawConstantValue(); + MetaType.NewLine(builder, indent + 1).Append(fieldInfo.Name).Append(" = ").Append(rawConstantValue).Append(";"); + } + } + } + else + { + foreach (ValueMember valueMember in array) + { + MetaType.NewLine(builder, indent + 1).Append(valueMember.Name).Append(" = ").Append(valueMember.FieldNumber).Append(';'); + } + } + MetaType.NewLine(builder, indent).Append('}'); + } + else + { + MetaType.NewLine(builder, indent).Append("message ").Append(this.GetSchemaTypeName()).Append(" {"); + foreach (ValueMember valueMember2 in array) + { + string value = (valueMember2.ItemType != null) ? "repeated" : (valueMember2.IsRequired ? "required" : "optional"); + MetaType.NewLine(builder, indent + 1).Append(value).Append(' '); + bool flag9 = valueMember2.DataFormat == DataFormat.Group; + if (flag9) + { + builder.Append("group "); + } + string schemaTypeName2 = valueMember2.GetSchemaTypeName(true, ref requiresBclImport); + builder.Append(schemaTypeName2).Append(" ").Append(valueMember2.Name).Append(" = ").Append(valueMember2.FieldNumber); + bool flag10 = valueMember2.DefaultValue != null; + if (flag10) + { + bool flag11 = valueMember2.DefaultValue is string; + if (flag11) + { + builder.Append(" [default = \"").Append(valueMember2.DefaultValue).Append("\"]"); + } + else + { + bool flag12 = valueMember2.DefaultValue is bool; + if (flag12) + { + builder.Append(((bool)valueMember2.DefaultValue) ? " [default = true]" : " [default = false]"); + } + else + { + builder.Append(" [default = ").Append(valueMember2.DefaultValue).Append(']'); + } + } + } + bool flag13 = valueMember2.ItemType != null && valueMember2.IsPacked; + if (flag13) + { + builder.Append(" [packed=true]"); + } + builder.Append(';'); + bool flag14 = schemaTypeName2 == "bcl.NetObjectProxy" && valueMember2.AsReference && !valueMember2.DynamicType; + if (flag14) + { + builder.Append(" // reference-tracked ").Append(valueMember2.GetSchemaTypeName(false, ref requiresBclImport)); + } + } + bool flag15 = this.subTypes != null && this.subTypes.Count != 0; + if (flag15) + { + MetaType.NewLine(builder, indent + 1).Append("// the following represent sub-types; at most 1 should have a value"); + SubType[] array6 = new SubType[this.subTypes.Count]; + this.subTypes.CopyTo(array6, 0); + Array.Sort(array6, SubType.Comparer.Default); + foreach (SubType subType in array6) + { + string schemaTypeName3 = subType.DerivedType.GetSchemaTypeName(); + MetaType.NewLine(builder, indent + 1).Append("optional ").Append(schemaTypeName3).Append(" ").Append(schemaTypeName3).Append(" = ").Append(subType.FieldNumber).Append(';'); + } + } + MetaType.NewLine(builder, indent).Append('}'); + } + } + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs.meta new file mode 100644 index 00000000..4dcc0567 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MetaType.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 9896348409133c84db5b167634c43101 +timeCreated: 1611404191 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs new file mode 100644 index 00000000..3afa5609 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs @@ -0,0 +1,29 @@ +using System; + +namespace ProtoBuf.Meta +{ + internal sealed class MutableList : BasicList + { + public new object this[int index] + { + get + { + return this.head[index]; + } + set + { + this.head[index] = value; + } + } + + public void RemoveLast() + { + this.head.RemoveLastWithMutate(); + } + + public new void Clear() + { + this.head.Clear(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs.meta new file mode 100644 index 00000000..0ee40320 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/MutableList.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 9075f746967b13049b559b21f9ba847f +timeCreated: 1611404139 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs new file mode 100644 index 00000000..2975c163 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs @@ -0,0 +1,1160 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using System.Text; +using System.Threading; +using ProtoBuf.Serializers; + +namespace ProtoBuf.Meta +{ + public sealed class RuntimeTypeModel : TypeModel + { + public bool InferTagFromNameDefault + { + get + { + return this.GetOption(1); + } + set + { + this.SetOption(1, value); + } + } + + public bool AutoAddProtoContractTypesOnly + { + get + { + return this.GetOption(128); + } + set + { + this.SetOption(128, value); + } + } + + public bool UseImplicitZeroDefaults + { + get + { + return this.GetOption(32); + } + set + { + bool flag = !value && this.GetOption(2); + if (flag) + { + throw new InvalidOperationException("UseImplicitZeroDefaults cannot be disabled on the default model"); + } + this.SetOption(32, value); + } + } + + public bool AllowParseableTypes + { + get + { + return this.GetOption(64); + } + set + { + this.SetOption(64, value); + } + } + + public static RuntimeTypeModel Default + { + get + { + return RuntimeTypeModel.Singleton.Value; + } + } + + public static RuntimeTypeModel ThreadDefault + { + get + { + return RuntimeTypeModel.Singleton.DefaultValue; + } + } + + public MetaType this[Type type] + { + get + { + return (MetaType)this.types[this.FindOrAddAuto(type, true, false, false)]; + } + } + + public bool AutoAddMissingTypes + { + get + { + return this.GetOption(8); + } + set + { + bool flag = !value && this.GetOption(2); + if (flag) + { + throw new InvalidOperationException("The default model must allow missing types"); + } + this.ThrowIfFrozen(); + this.SetOption(8, value); + } + } + + public int MetadataTimeoutMilliseconds + { + get + { + return this.metadataTimeoutMilliseconds; + } + set + { + bool flag = value <= 0; + if (flag) + { + throw new ArgumentOutOfRangeException("MetadataTimeoutMilliseconds"); + } + this.metadataTimeoutMilliseconds = value; + } + } + + public int LockCount + { + get + { + return this.lockCount; + } + } + + public event LockContentedEventHandler LockContended; + + private byte options; + + private const byte OPTIONS_InferTagFromNameDefault = 1; + + private const byte OPTIONS_IsDefaultModel = 2; + + private const byte OPTIONS_Frozen = 4; + + private const byte OPTIONS_AutoAddMissingTypes = 8; + + private const byte OPTIONS_UseImplicitZeroDefaults = 32; + + private const byte OPTIONS_AllowParseableTypes = 64; + + private const byte OPTIONS_AutoAddProtoContractTypesOnly = 128; + + private static readonly BasicList.MatchPredicate MetaTypeFinder = new BasicList.MatchPredicate(RuntimeTypeModel.MetaTypeFinderImpl); + + private static readonly BasicList.MatchPredicate BasicTypeFinder = new BasicList.MatchPredicate(RuntimeTypeModel.BasicTypeFinderImpl); + + private BasicList basicTypes = new BasicList(); + + private readonly BasicList types = new BasicList(); + + private int metadataTimeoutMilliseconds = 5000; + + private int lockCount; + + private int contentionCounter = 1; + + private MethodInfo defaultFactory; + + private sealed class Singleton + { + internal static readonly RuntimeTypeModel Value = new RuntimeTypeModel(true); + + private static RuntimeTypeModel ThreadValue = null; + + internal static RuntimeTypeModel DefaultValue = null; + + private Singleton() + { + } + + public static void SetMultiThread(bool multiThread) + { + if (multiThread) + { + RuntimeTypeModel.Singleton.ThreadValue = new RuntimeTypeModel(true); + RuntimeTypeModel.Singleton.DefaultValue = RuntimeTypeModel.Singleton.ThreadValue; + } + else + { + RuntimeTypeModel.Singleton.DefaultValue = RuntimeTypeModel.Singleton.Value; + } + } + } + + private sealed class BasicType + { + public Type Type + { + get + { + return this.type; + } + } + + public IProtoSerializer Serializer + { + get + { + return this.serializer; + } + } + + private readonly Type type; + + private readonly IProtoSerializer serializer; + + public BasicType(Type type, IProtoSerializer serializer) + { + this.type = type; + this.serializer = serializer; + } + } + + private bool GetOption(byte option) + { + return (this.options & option) == option; + } + + private void SetOption(byte option, bool value) + { + if (value) + { + this.options |= option; + } + else + { + this.options &=(byte) ~option; + } + } + + public static void SetMultiThread(bool multiThread) + { + RuntimeTypeModel.Singleton.SetMultiThread(multiThread); + } + + public IEnumerable GetTypes() + { + return this.types; + } + + public override string GetSchema(Type type) + { + BasicList basicList = new BasicList(); + MetaType metaType = null; + bool flag = false; + bool flag2 = type == null; + if (flag2) + { + foreach (object obj in this.types) + { + MetaType metaType2 = (MetaType)obj; + MetaType surrogateOrBaseOrSelf = metaType2.GetSurrogateOrBaseOrSelf(false); + bool flag3 = !basicList.Contains(surrogateOrBaseOrSelf); + if (flag3) + { + basicList.Add(surrogateOrBaseOrSelf); + this.CascadeDependents(basicList, surrogateOrBaseOrSelf); + } + } + } + else + { + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag4 = underlyingType != null; + if (flag4) + { + type = underlyingType; + } + WireType wireType; + flag = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType, false, false, false, false) != null); + bool flag5 = !flag; + if (flag5) + { + int num = this.FindOrAddAuto(type, false, false, false); + bool flag6 = num < 0; + if (flag6) + { + throw new ArgumentException("The type specified is not a contract-type", "type"); + } + metaType = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false); + basicList.Add(metaType); + this.CascadeDependents(basicList, metaType); + } + } + StringBuilder stringBuilder = new StringBuilder(); + string text = null; + bool flag7 = !flag; + if (flag7) + { + IEnumerable enumerable = (metaType == null) ? this.types : basicList; + foreach (object obj2 in enumerable) + { + MetaType metaType3 = (MetaType)obj2; + bool isList = metaType3.IsList; + if (!isList) + { + string @namespace = metaType3.Type.Namespace; + bool flag8 = !Helpers.IsNullOrEmpty(@namespace); + if (flag8) + { + bool flag9 = @namespace.StartsWith("System."); + if (!flag9) + { + bool flag10 = text == null; + if (flag10) + { + text = @namespace; + } + else + { + bool flag11 = text == @namespace; + if (!flag11) + { + text = null; + break; + } + } + } + } + } + } + } + bool flag12 = !Helpers.IsNullOrEmpty(text); + if (flag12) + { + stringBuilder.Append("package ").Append(text).Append(';'); + Helpers.AppendLine(stringBuilder); + } + bool flag13 = false; + StringBuilder stringBuilder2 = new StringBuilder(); + MetaType[] array = new MetaType[basicList.Count]; + basicList.CopyTo(array, 0); + Array.Sort(array, MetaType.Comparer.Default); + bool flag14 = flag; + if (flag14) + { + Helpers.AppendLine(stringBuilder2).Append("message ").Append(type.Name).Append(" {"); + MetaType.NewLine(stringBuilder2, 1).Append("optional ").Append(this.GetSchemaTypeName(type, DataFormat.Default, false, false, ref flag13)).Append(" value = 1;"); + Helpers.AppendLine(stringBuilder2).Append('}'); + } + else + { + foreach (MetaType metaType4 in array) + { + bool flag15 = metaType4.IsList && metaType4 != metaType; + if (!flag15) + { + metaType4.WriteSchema(stringBuilder2, 0, ref flag13); + } + } + } + bool flag16 = flag13; + if (flag16) + { + stringBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types"); + Helpers.AppendLine(stringBuilder); + } + return Helpers.AppendLine(stringBuilder.Append(stringBuilder2)).ToString(); + } + + private void CascadeDependents(BasicList list, MetaType metaType) + { + bool isList = metaType.IsList; + if (isList) + { + Type listItemType = TypeModel.GetListItemType(this, metaType.Type); + WireType wireType; + IProtoSerializer protoSerializer = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out wireType, false, false, false, false); + bool flag = protoSerializer == null; + if (flag) + { + int num = this.FindOrAddAuto(listItemType, false, false, false); + bool flag2 = num >= 0; + if (flag2) + { + MetaType metaType2 = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false); + bool flag3 = !list.Contains(metaType2); + if (flag3) + { + list.Add(metaType2); + this.CascadeDependents(list, metaType2); + } + } + } + } + else + { + bool isAutoTuple = metaType.IsAutoTuple; + MetaType metaType2; + if (isAutoTuple) + { + MemberInfo[] array; + bool flag4 = MetaType.ResolveTupleConstructor(metaType.Type, out array) != null; + if (flag4) + { + for (int i = 0; i < array.Length; i++) + { + Type type = null; + bool flag5 = array[i] is PropertyInfo; + if (flag5) + { + type = ((PropertyInfo)array[i]).PropertyType; + } + else + { + bool flag6 = array[i] is FieldInfo; + if (flag6) + { + type = ((FieldInfo)array[i]).FieldType; + } + } + WireType wireType2; + IProtoSerializer protoSerializer2 = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType2, false, false, false, false); + bool flag7 = protoSerializer2 == null; + if (flag7) + { + int num2 = this.FindOrAddAuto(type, false, false, false); + bool flag8 = num2 >= 0; + if (flag8) + { + metaType2 = ((MetaType)this.types[num2]).GetSurrogateOrBaseOrSelf(false); + bool flag9 = !list.Contains(metaType2); + if (flag9) + { + list.Add(metaType2); + this.CascadeDependents(list, metaType2); + } + } + } + } + } + } + else + { + foreach (object obj in metaType.Fields) + { + ValueMember valueMember = (ValueMember)obj; + Type type2 = valueMember.ItemType; + bool flag10 = type2 == null; + if (flag10) + { + type2 = valueMember.MemberType; + } + WireType wireType3; + IProtoSerializer protoSerializer3 = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type2, out wireType3, false, false, false, false); + bool flag11 = protoSerializer3 == null; + if (flag11) + { + int num3 = this.FindOrAddAuto(type2, false, false, false); + bool flag12 = num3 >= 0; + if (flag12) + { + metaType2 = ((MetaType)this.types[num3]).GetSurrogateOrBaseOrSelf(false); + bool flag13 = !list.Contains(metaType2); + if (flag13) + { + list.Add(metaType2); + this.CascadeDependents(list, metaType2); + } + } + } + } + } + bool hasSubtypes = metaType.HasSubtypes; + if (hasSubtypes) + { + foreach (SubType subType in metaType.GetSubtypes()) + { + metaType2 = subType.DerivedType.GetSurrogateOrSelf(); + bool flag14 = !list.Contains(metaType2); + if (flag14) + { + list.Add(metaType2); + this.CascadeDependents(list, metaType2); + } + } + } + metaType2 = metaType.BaseType; + bool flag15 = metaType2 != null; + if (flag15) + { + metaType2 = metaType2.GetSurrogateOrSelf(); + } + bool flag16 = metaType2 != null && !list.Contains(metaType2); + if (flag16) + { + list.Add(metaType2); + this.CascadeDependents(list, metaType2); + } + } + } + + internal RuntimeTypeModel(bool isDefault) + { + this.AutoAddMissingTypes = true; + this.UseImplicitZeroDefaults = true; + this.SetOption(2, isDefault); + } + + internal MetaType FindWithoutAdd(Type type) + { + foreach (object obj in this.types) + { + MetaType metaType = (MetaType)obj; + bool flag = metaType.Type == type; + if (flag) + { + bool pending = metaType.Pending; + if (pending) + { + this.WaitOnLock(metaType); + } + return metaType; + } + } + Type type2 = TypeModel.ResolveProxies(type); + return (type2 == null) ? null : this.FindWithoutAdd(type2); + } + + private static bool MetaTypeFinderImpl(object value, object ctx) + { + return ((MetaType)value).Type == (Type)ctx; + } + + private static bool BasicTypeFinderImpl(object value, object ctx) + { + return ((RuntimeTypeModel.BasicType)value).Type == (Type)ctx; + } + + private void WaitOnLock(MetaType type) + { + int opaqueToken = 0; + try + { + this.TakeLock(ref opaqueToken); + } + finally + { + this.ReleaseLock(opaqueToken); + } + } + + internal IProtoSerializer TryGetBasicTypeSerializer(Type type) + { + int num = this.basicTypes.IndexOf(RuntimeTypeModel.BasicTypeFinder, type); + bool flag = num >= 0; + IProtoSerializer result; + if (flag) + { + result = ((RuntimeTypeModel.BasicType)this.basicTypes[num]).Serializer; + } + else + { + BasicList obj = this.basicTypes; + lock (obj) + { + num = this.basicTypes.IndexOf(RuntimeTypeModel.BasicTypeFinder, type); + bool flag2 = num >= 0; + if (flag2) + { + result = ((RuntimeTypeModel.BasicType)this.basicTypes[num]).Serializer; + } + else + { + MetaType.AttributeFamily contractFamily = MetaType.GetContractFamily(this, type, null); + WireType wireType; + IProtoSerializer protoSerializer = (contractFamily == MetaType.AttributeFamily.None) ? ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType, false, false, false, false) : null; + bool flag3 = protoSerializer != null; + if (flag3) + { + this.basicTypes.Add(new RuntimeTypeModel.BasicType(type, protoSerializer)); + } + result = protoSerializer; + } + } + } + return result; + } + + public void Clear() + { + this.types.Clear(); + } + + internal int FindOrAddAuto(Type type, bool demand, bool addWithContractOnly, bool addEvenIfAutoDisabled) + { + int num = this.types.IndexOf(RuntimeTypeModel.MetaTypeFinder, type); + bool flag = num >= 0; + int result; + if (flag) + { + MetaType metaType = (MetaType)this.types[num]; + bool pending = metaType.Pending; + if (pending) + { + this.WaitOnLock(metaType); + } + result = num; + } + else + { + bool flag2 = this.AutoAddMissingTypes || addEvenIfAutoDisabled; + bool flag3 = !Helpers.IsEnum(type) && this.TryGetBasicTypeSerializer(type) != null; + if (flag3) + { + bool flag4 = flag2 && !addWithContractOnly; + if (flag4) + { + throw MetaType.InbuiltType(type); + } + result = -1; + } + else + { + Type type2 = TypeModel.ResolveProxies(type); + bool flag5 = type2 != null; + if (flag5) + { + num = this.types.IndexOf(RuntimeTypeModel.MetaTypeFinder, type2); + type = type2; + } + bool flag6 = num < 0; + if (flag6) + { + int opaqueToken = 0; + try + { + this.TakeLock(ref opaqueToken); + MetaType metaType; + bool flag7 = (metaType = this.RecogniseCommonTypes(type)) == null; + if (flag7) + { + MetaType.AttributeFamily contractFamily = MetaType.GetContractFamily(this, type, null); + bool flag8 = contractFamily == MetaType.AttributeFamily.AutoTuple; + if (flag8) + { + addEvenIfAutoDisabled = (flag2 = true); + } + bool flag9 = !flag2 || (!Helpers.IsEnum(type) && addWithContractOnly && contractFamily == MetaType.AttributeFamily.None); + if (flag9) + { + if (demand) + { + TypeModel.ThrowUnexpectedType(type); + } + return num; + } + metaType = this.Create(type); + } + metaType.Pending = true; + bool flag10 = false; + int num2 = this.types.IndexOf(RuntimeTypeModel.MetaTypeFinder, type); + bool flag11 = num2 < 0; + if (flag11) + { + this.ThrowIfFrozen(); + num = this.types.Add(metaType); + flag10 = true; + } + else + { + num = num2; + } + bool flag12 = flag10; + if (flag12) + { + metaType.ApplyDefaultBehaviour(); + metaType.Pending = false; + } + } + finally + { + this.ReleaseLock(opaqueToken); + } + } + result = num; + } + } + return result; + } + + private MetaType RecogniseCommonTypes(Type type) + { + return null; + } + + private MetaType Create(Type type) + { + this.ThrowIfFrozen(); + return new MetaType(this, type, this.defaultFactory); + } + + public MetaType Add(Type type, bool applyDefaultBehaviour) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + MetaType metaType = this.FindWithoutAdd(type); + bool flag2 = metaType != null; + MetaType result; + if (flag2) + { + result = metaType; + } + else + { + int opaqueToken = 0; + bool flag3 = type.IsInterface && base.MapType(MetaType.ienumerable).IsAssignableFrom(type) && TypeModel.GetListItemType(this, type) == null; + if (flag3) + { + throw new ArgumentException("IEnumerable[] data cannot be used as a meta-type unless an Add method can be resolved"); + } + try + { + metaType = this.RecogniseCommonTypes(type); + bool flag4 = metaType != null; + if (flag4) + { + bool flag5 = !applyDefaultBehaviour; + if (flag5) + { + throw new ArgumentException("Default behaviour must be observed for certain types with special handling; " + type.FullName, "applyDefaultBehaviour"); + } + applyDefaultBehaviour = false; + } + bool flag6 = metaType == null; + if (flag6) + { + metaType = this.Create(type); + } + metaType.Pending = true; + this.TakeLock(ref opaqueToken); + bool flag7 = this.FindWithoutAdd(type) != null; + if (flag7) + { + throw new ArgumentException("Duplicate type", "type"); + } + this.ThrowIfFrozen(); + this.types.Add(metaType); + bool flag8 = applyDefaultBehaviour; + if (flag8) + { + metaType.ApplyDefaultBehaviour(); + } + metaType.Pending = false; + } + finally + { + this.ReleaseLock(opaqueToken); + } + result = metaType; + } + return result; + } + + private void ThrowIfFrozen() + { + bool option = this.GetOption(4); + if (option) + { + throw new InvalidOperationException("The model cannot be changed once frozen"); + } + } + + public void Freeze() + { + bool option = this.GetOption(2); + if (option) + { + throw new InvalidOperationException("The default model cannot be frozen"); + } + this.SetOption(4, true); + } + + protected override int GetKeyImpl(Type type) + { + return this.GetKey(type, false, true); + } + + internal int GetKey(Type type, bool demand, bool getBaseKey) + { + Helpers.DebugAssert(type != null); + int result; + try + { + int num = this.FindOrAddAuto(type, demand, true, false); + bool flag = num >= 0; + if (flag) + { + MetaType metaType = (MetaType)this.types[num]; + if (getBaseKey) + { + metaType = MetaType.GetRootType(metaType); + num = this.FindOrAddAuto(metaType.Type, true, true, false); + } + } + result = num; + } + catch (NotSupportedException) + { + throw; + } + catch (Exception ex) + { + bool flag2 = ex.Message.IndexOf(type.FullName) >= 0; + if (flag2) + { + throw; + } + throw new ProtoException(ex.Message + " (" + type.FullName + ")", ex); + } + return result; + } + + protected internal override void Serialize(int key, object value, ProtoWriter dest) + { + ((MetaType)this.types[key]).Serializer.Write(value, dest); + } + + protected internal override object Deserialize(int key, object value, ProtoReader source) + { + IProtoSerializer serializer = ((MetaType)this.types[key]).Serializer; + bool flag = value == null && Helpers.IsValueType(serializer.ExpectedType); + object result; + if (flag) + { + bool requiresOldValue = serializer.RequiresOldValue; + if (requiresOldValue) + { + value = Activator.CreateInstance(serializer.ExpectedType); + } + result = serializer.Read(value, source); + } + else + { + result = serializer.Read(value, source); + } + return result; + } + + internal bool IsPrepared(Type type) + { + MetaType metaType = this.FindWithoutAdd(type); + return metaType != null && metaType.IsPrepared(); + } + + internal EnumSerializer.EnumPair[] GetEnumMap(Type type) + { + int num = this.FindOrAddAuto(type, false, false, false); + return (num < 0) ? null : ((MetaType)this.types[num]).GetEnumMap(); + } + + internal void TakeLock(ref int opaqueToken) + { + opaqueToken = 0; + bool flag = Monitor.TryEnter(this.types, this.metadataTimeoutMilliseconds); + if (flag) + { + opaqueToken = this.GetContention(); + this.lockCount++; + return; + } + this.AddContention(); + throw new TimeoutException("Timeout while inspecting metadata; this may indicate a deadlock. This can often be avoided by preparing necessary serializers during application initialization, rather than allowing multiple threads to perform the initial metadata inspection; please also see the LockContended event"); + } + + private int GetContention() + { + return Interlocked.CompareExchange(ref this.contentionCounter, 0, 0); + } + + private void AddContention() + { + Interlocked.Increment(ref this.contentionCounter); + } + + internal void ReleaseLock(int opaqueToken) + { + bool flag = opaqueToken != 0; + if (flag) + { + Monitor.Exit(this.types); + bool flag2 = opaqueToken != this.GetContention(); + if (flag2) + { + LockContentedEventHandler lockContended = this.LockContended; + bool flag3 = lockContended != null; + if (flag3) + { + string stackTrace; + try + { + throw new ProtoException(); + } + catch (Exception ex) + { + stackTrace = ex.StackTrace; + } + lockContended(this, new LockContentedEventArgs(stackTrace)); + } + } + } + } + + internal void ResolveListTypes(Type type, ref Type itemType, ref Type defaultType) + { + bool flag = type == null; + if (!flag) + { + bool flag2 = Helpers.GetTypeCode(type) != ProtoTypeCode.Unknown; + if (!flag2) + { + bool ignoreListHandling = this[type].IgnoreListHandling; + if (!ignoreListHandling) + { + bool isArray = type.IsArray; + if (isArray) + { + bool flag3 = type.GetArrayRank() != 1; + if (flag3) + { + throw new NotSupportedException("Multi-dimension arrays are supported"); + } + itemType = type.GetElementType(); + bool flag4 = itemType == base.MapType(typeof(byte)); + if (flag4) + { + Type type2; + itemType = (type2 = null); + defaultType = type2; + } + else + { + defaultType = type; + } + } + bool flag5 = itemType == null; + if (flag5) + { + itemType = TypeModel.GetListItemType(this, type); + } + bool flag6 = itemType != null; + if (flag6) + { + Type type3 = null; + Type type4 = null; + this.ResolveListTypes(itemType, ref type3, ref type4); + bool flag7 = type3 != null; + if (flag7) + { + throw TypeModel.CreateNestedListsNotSupported(); + } + } + bool flag8 = itemType != null && defaultType == null; + if (flag8) + { + bool flag9 = type.IsClass && !type.IsAbstract && Helpers.GetConstructor(type, Helpers.EmptyTypes, true) != null; + if (flag9) + { + defaultType = type; + } + bool flag10 = defaultType == null; + if (flag10) + { + bool isInterface = type.IsInterface; + if (isInterface) + { + Type[] genericArguments = null; + bool flag11 = type.IsGenericType && type.GetGenericTypeDefinition() == base.MapType(typeof(IDictionary<, >)) && itemType == base.MapType(typeof(KeyValuePair<, >)).MakeGenericType(genericArguments = type.GetGenericArguments()); + if (flag11) + { + defaultType = base.MapType(typeof(Dictionary<, >)).MakeGenericType(genericArguments); + } + else + { + defaultType = base.MapType(typeof(List<>)).MakeGenericType(new Type[] + { + itemType + }); + } + } + } + bool flag12 = defaultType != null && !Helpers.IsAssignableFrom(type, defaultType); + if (flag12) + { + defaultType = null; + } + } + } + } + } + } + + internal string GetSchemaTypeName(Type effectiveType, DataFormat dataFormat, bool asReference, bool dynamicType, ref bool requiresBclImport) + { + Type underlyingType = Helpers.GetUnderlyingType(effectiveType); + bool flag = underlyingType != null; + if (flag) + { + effectiveType = underlyingType; + } + bool flag2 = effectiveType == base.MapType(typeof(byte[])); + string result; + if (flag2) + { + result = "bytes"; + } + else + { + WireType wireType; + IProtoSerializer protoSerializer = ValueMember.TryGetCoreSerializer(this, dataFormat, effectiveType, out wireType, false, false, false, false); + bool flag3 = protoSerializer == null; + if (flag3) + { + bool flag4 = asReference || dynamicType; + if (flag4) + { + requiresBclImport = true; + result = "bcl.NetObjectProxy"; + } + else + { + result = this[effectiveType].GetSurrogateOrBaseOrSelf(true).GetSchemaTypeName(); + } + } + else + { + bool flag5 = protoSerializer is ParseableSerializer; + if (!flag5) + { + ProtoTypeCode typeCode = Helpers.GetTypeCode(effectiveType); + switch (typeCode) + { + case ProtoTypeCode.Boolean: + return "bool"; + case ProtoTypeCode.Char: + case ProtoTypeCode.Byte: + case ProtoTypeCode.UInt16: + case ProtoTypeCode.UInt32: + if (dataFormat != DataFormat.FixedSize) + { + return "uint32"; + } + return "fixed32"; + case ProtoTypeCode.SByte: + case ProtoTypeCode.Int16: + case ProtoTypeCode.Int32: + if (dataFormat == DataFormat.ZigZag) + { + return "sint32"; + } + if (dataFormat != DataFormat.FixedSize) + { + return "int32"; + } + return "sfixed32"; + case ProtoTypeCode.Int64: + if (dataFormat == DataFormat.ZigZag) + { + return "sint64"; + } + if (dataFormat != DataFormat.FixedSize) + { + return "int64"; + } + return "sfixed64"; + case ProtoTypeCode.UInt64: + if (dataFormat != DataFormat.FixedSize) + { + return "uint64"; + } + return "fixed64"; + case ProtoTypeCode.Single: + return "float"; + case ProtoTypeCode.Double: + return "double"; + case ProtoTypeCode.Decimal: + requiresBclImport = true; + return "bcl.Decimal"; + case ProtoTypeCode.DateTime: + requiresBclImport = true; + return "bcl.DateTime"; + case (ProtoTypeCode)17: + break; + case ProtoTypeCode.String: + if (asReference) + { + requiresBclImport = true; + } + return asReference ? "bcl.NetObjectProxy" : "string"; + default: + if (typeCode == ProtoTypeCode.TimeSpan) + { + requiresBclImport = true; + return "bcl.TimeSpan"; + } + if (typeCode == ProtoTypeCode.Guid) + { + requiresBclImport = true; + return "bcl.Guid"; + } + break; + } + throw new NotSupportedException("No .proto map found for: " + effectiveType.FullName); + } + if (asReference) + { + requiresBclImport = true; + } + result = (asReference ? "bcl.NetObjectProxy" : "string"); + } + } + return result; + } + + public void SetDefaultFactory(MethodInfo methodInfo) + { + this.VerifyFactory(methodInfo, null); + this.defaultFactory = methodInfo; + } + + internal void VerifyFactory(MethodInfo factory, Type type) + { + bool flag = factory != null; + if (flag) + { + bool flag2 = type != null && Helpers.IsValueType(type); + if (flag2) + { + throw new InvalidOperationException(); + } + bool flag3 = !factory.IsStatic; + if (flag3) + { + throw new ArgumentException("A factory-method must be static", "factory"); + } + bool flag4 = type != null && factory.ReturnType != type && factory.ReturnType != base.MapType(typeof(object)); + if (flag4) + { + throw new ArgumentException("The factory-method must return object" + ((type == null) ? "" : (" or " + type.FullName)), "factory"); + } + bool flag5 = !CallbackSet.CheckCallbackParameters(this, factory); + if (flag5) + { + throw new ArgumentException("Invalid factory signature in " + factory.DeclaringType.FullName + "." + factory.Name, "factory"); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs.meta new file mode 100644 index 00000000..547e89c2 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/RuntimeTypeModel.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 05191c47ba04cdf4e9b086621a0fb424 +timeCreated: 1611402962 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs new file mode 100644 index 00000000..6686ab73 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs @@ -0,0 +1,117 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using ProtoBuf.Serializers; + +namespace ProtoBuf.Meta +{ + public sealed class SubType + { + public int FieldNumber + { + get + { + return this.fieldNumber; + } + } + + public MetaType DerivedType + { + get + { + return this.derivedType; + } + } + + internal IProtoSerializer Serializer + { + get + { + bool flag = this.serializer == null; + if (flag) + { + this.serializer = this.BuildSerializer(); + } + return this.serializer; + } + } + + private readonly int fieldNumber; + + private readonly MetaType derivedType; + + private readonly DataFormat dataFormat; + + private IProtoSerializer serializer; + + internal sealed class Comparer : IComparer, IComparer + { + public static readonly SubType.Comparer Default = new SubType.Comparer(); + + public int Compare(object x, object y) + { + return this.Compare(x as SubType, y as SubType); + } + + public int Compare(SubType x, SubType y) + { + bool flag = x == y; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x == null; + if (flag2) + { + result = -1; + } + else + { + bool flag3 = y == null; + if (flag3) + { + result = 1; + } + else + { + result = x.FieldNumber.CompareTo(y.FieldNumber); + } + } + } + return result; + } + } + + public SubType(int fieldNumber, MetaType derivedType, DataFormat format) + { + bool flag = derivedType == null; + if (flag) + { + throw new ArgumentNullException("derivedType"); + } + bool flag2 = fieldNumber <= 0; + if (flag2) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + this.fieldNumber = fieldNumber; + this.derivedType = derivedType; + this.dataFormat = format; + } + + private IProtoSerializer BuildSerializer() + { + WireType wireType = WireType.String; + bool flag = this.dataFormat == DataFormat.Group; + if (flag) + { + wireType = WireType.StartGroup; + } + IProtoSerializer tail = new SubItemSerializer(this.derivedType.Type, this.derivedType.GetKey(false, false), this.derivedType, false); + return new TagDecorator(this.fieldNumber, wireType, false, tail); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs.meta new file mode 100644 index 00000000..dd423340 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/SubType.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c96bdfea838c34b4c8d995ee6bd2940f +timeCreated: 1611404538 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs new file mode 100644 index 00000000..ec466502 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs @@ -0,0 +1,76 @@ +using System; + +namespace ProtoBuf.Meta +{ + public class TypeFormatEventArgs : EventArgs + { + public Type Type + { + get + { + return this.type; + } + set + { + bool flag = this.type != value; + if (flag) + { + bool flag2 = this.typeFixed; + if (flag2) + { + throw new InvalidOperationException("The type is fixed and cannot be changed"); + } + this.type = value; + } + } + } + + public string FormattedName + { + get + { + return this.formattedName; + } + set + { + bool flag = this.formattedName != value; + if (flag) + { + bool flag2 = !this.typeFixed; + if (flag2) + { + throw new InvalidOperationException("The formatted-name is fixed and cannot be changed"); + } + this.formattedName = value; + } + } + } + + private Type type; + + private string formattedName; + + private readonly bool typeFixed; + + internal TypeFormatEventArgs(string formattedName) + { + bool flag = Helpers.IsNullOrEmpty(formattedName); + if (flag) + { + throw new ArgumentNullException("formattedName"); + } + this.formattedName = formattedName; + } + + internal TypeFormatEventArgs(Type type) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + this.type = type; + this.typeFixed = true; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs.meta new file mode 100644 index 00000000..3699b0eb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 22ffb555f8ce6f64aaf7b82ffbe091a3 +timeCreated: 1611403425 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs new file mode 100644 index 00000000..54e34016 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs @@ -0,0 +1,6 @@ +using System; + +namespace ProtoBuf.Meta +{ + public delegate void TypeFormatEventHandler(object sender, TypeFormatEventArgs args); +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs.meta new file mode 100644 index 00000000..47deaaff --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeFormatEventHandler.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 0741ed768de0a8d429019e070d73a230 +timeCreated: 1611402967 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs new file mode 100644 index 00000000..018d47c0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs @@ -0,0 +1,1511 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Runtime.CompilerServices; +using ProtoBuf.Serializers; + +namespace ProtoBuf.Meta +{ + public abstract class TypeModel + { + public bool ForwardsOnly + { + get + { + return this.forwardsOnly; + } + set + { + this.forwardsOnly = value; + } + } + + public event TypeFormatEventHandler DynamicTypeFormatting; + + private static readonly Type ilist = typeof(IList); + + private bool forwardsOnly; + + private sealed class DeserializeItemsIterator : TypeModel.DeserializeItemsIterator, IEnumerator, IEnumerator, IDisposable, IEnumerable, IEnumerable + { + public new T Current + { + get + { + return (T)((object)base.Current); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this; + } + + void IDisposable.Dispose() + { + } + + public DeserializeItemsIterator(TypeModel model, Stream source, PrefixStyle style, int expectedField, SerializationContext context) : base(model, source, model.MapType(typeof(T)), style, expectedField, null, context) + { + } + } + + private class DeserializeItemsIterator : IEnumerator, IEnumerable + { + public object Current + { + get + { + return this.current; + } + } + + private bool haveObject; + + private object current; + + private readonly Stream source; + + private readonly Type type; + + private readonly PrefixStyle style; + + private readonly int expectedField; + + private readonly Serializer.TypeResolver resolver; + + private readonly TypeModel model; + + private readonly SerializationContext context; + + IEnumerator IEnumerable.GetEnumerator() + { + return this; + } + + public bool MoveNext() + { + bool flag = this.haveObject; + if (flag) + { + int num; + this.current = this.model.DeserializeWithLengthPrefix(this.source, null, this.type, this.style, this.expectedField, this.resolver, out num, out this.haveObject, this.context); + } + return this.haveObject; + } + + void IEnumerator.Reset() + { + throw new NotSupportedException(); + } + + public DeserializeItemsIterator(TypeModel model, Stream source, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, SerializationContext context) + { + this.haveObject = true; + this.source = source; + this.type = type; + this.style = style; + this.expectedField = expectedField; + this.resolver = resolver; + this.model = model; + this.context = context; + } + } + + protected internal enum CallbackType + { + BeforeSerialize, + AfterSerialize, + BeforeDeserialize, + AfterDeserialize + } + + protected internal Type MapType(Type type) + { + return this.MapType(type, true); + } + + protected internal virtual Type MapType(Type type, bool demand) + { + return type; + } + + private WireType GetWireType(ProtoTypeCode code, DataFormat format, ref Type type, out int modelKey) + { + modelKey = -1; + bool flag = Helpers.IsEnum(type); + WireType result = WireType.None;//! + if (flag) + { + modelKey = this.GetKey(ref type); + result = WireType.Variant; + } + else + { + switch (code) + { + case ProtoTypeCode.Boolean: + case ProtoTypeCode.Char: + case ProtoTypeCode.SByte: + case ProtoTypeCode.Byte: + case ProtoTypeCode.Int16: + case ProtoTypeCode.UInt16: + case ProtoTypeCode.Int32: + case ProtoTypeCode.UInt32: + return (format == DataFormat.FixedSize) ? WireType.Fixed32 : WireType.Variant; + case ProtoTypeCode.Int64: + case ProtoTypeCode.UInt64: + return (format == DataFormat.FixedSize) ? WireType.Fixed64 : WireType.Variant; + case ProtoTypeCode.Single: + return WireType.Fixed32; + case ProtoTypeCode.Double: + return WireType.Fixed64; + case ProtoTypeCode.Decimal: + case ProtoTypeCode.DateTime: + case ProtoTypeCode.String: + break; + case (ProtoTypeCode)17: + goto IL_99; + default: + if (code - ProtoTypeCode.TimeSpan > 3) + { + goto IL_99; + } + break; + } + return WireType.String; + IL_99: + bool flag2 = (modelKey = this.GetKey(ref type)) >= 0; + if (flag2) + { + result = WireType.String; + } + else + { + result = WireType.None; + } + } + return result; + } + + internal bool TrySerializeAuxiliaryType(ProtoWriter writer, Type type, DataFormat format, int tag, object value, bool isInsideList) + { + bool flag = type == null; + if (flag) + { + type = value.GetType(); + } + ProtoTypeCode typeCode = Helpers.GetTypeCode(type); + int num; + WireType wireType = this.GetWireType(typeCode, format, ref type, out num); + bool flag2 = num >= 0; + bool result; + if (flag2) + { + bool flag3 = Helpers.IsEnum(type); + if (flag3) + { + this.Serialize(num, value, writer); + result = true; + } + else + { + ProtoWriter.WriteFieldHeader(tag, wireType, writer); + WireType wireType2 = wireType; + if (wireType2 == WireType.None) + { + throw ProtoWriter.CreateException(writer); + } + if (wireType2 - WireType.String > 1) + { + this.Serialize(num, value, writer); + result = true; + } + else + { + SubItemToken token = ProtoWriter.StartSubItem(value, writer); + this.Serialize(num, value, writer); + ProtoWriter.EndSubItem(token, writer); + result = true; + } + } + } + else + { + bool flag4 = wireType != WireType.None; + if (flag4) + { + ProtoWriter.WriteFieldHeader(tag, wireType, writer); + } + ProtoTypeCode protoTypeCode = typeCode; + switch (protoTypeCode) + { + case ProtoTypeCode.Boolean: + ProtoWriter.WriteBoolean((bool)value, writer); + return true; + case ProtoTypeCode.Char: + ProtoWriter.WriteUInt16((ushort)((char)value), writer); + return true; + case ProtoTypeCode.SByte: + ProtoWriter.WriteSByte((sbyte)value, writer); + return true; + case ProtoTypeCode.Byte: + ProtoWriter.WriteByte((byte)value, writer); + return true; + case ProtoTypeCode.Int16: + ProtoWriter.WriteInt16((short)value, writer); + return true; + case ProtoTypeCode.UInt16: + ProtoWriter.WriteUInt16((ushort)value, writer); + return true; + case ProtoTypeCode.Int32: + ProtoWriter.WriteInt32((int)value, writer); + return true; + case ProtoTypeCode.UInt32: + ProtoWriter.WriteUInt32((uint)value, writer); + return true; + case ProtoTypeCode.Int64: + ProtoWriter.WriteInt64((long)value, writer); + return true; + case ProtoTypeCode.UInt64: + ProtoWriter.WriteUInt64((ulong)value, writer); + return true; + case ProtoTypeCode.Single: + ProtoWriter.WriteSingle((float)value, writer); + return true; + case ProtoTypeCode.Double: + ProtoWriter.WriteDouble((double)value, writer); + return true; + case ProtoTypeCode.Decimal: + BclHelpers.WriteDecimal((decimal)value, writer); + return true; + case ProtoTypeCode.DateTime: + BclHelpers.WriteDateTime((DateTime)value, writer); + return true; + case (ProtoTypeCode)17: + break; + case ProtoTypeCode.String: + ProtoWriter.WriteString((string)value, writer); + return true; + default: + switch (protoTypeCode) + { + case ProtoTypeCode.TimeSpan: + BclHelpers.WriteTimeSpan((TimeSpan)value, writer); + return true; + case ProtoTypeCode.ByteArray: + ProtoWriter.WriteBytes((byte[])value, writer); + return true; + case ProtoTypeCode.Guid: + BclHelpers.WriteGuid((Guid)value, writer); + return true; + case ProtoTypeCode.Uri: + ProtoWriter.WriteString(((Uri)value).AbsoluteUri, writer); + return true; + } + break; + } + Helpers.DebugAssert(wireType == WireType.None); + IEnumerable enumerable = value as IEnumerable; + bool flag5 = enumerable != null; + if (flag5) + { + if (isInsideList) + { + throw TypeModel.CreateNestedListsNotSupported(); + } + foreach (object obj in enumerable) + { + bool flag6 = obj == null; + if (flag6) + { + throw new NullReferenceException(); + } + bool flag7 = !this.TrySerializeAuxiliaryType(writer, null, format, tag, obj, true); + if (flag7) + { + TypeModel.ThrowUnexpectedType(obj.GetType()); + } + } + result = true; + } + else + { + result = false; + } + } + return result; + } + + private void SerializeCore(ProtoWriter writer, object value) + { + bool flag = value == null; + if (flag) + { + throw new ArgumentNullException("value"); + } + Type type = value.GetType(); + int key = this.GetKey(ref type); + bool flag2 = key >= 0; + if (flag2) + { + this.Serialize(key, value, writer); + } + else + { + bool flag3 = !this.TrySerializeAuxiliaryType(writer, type, DataFormat.Default, 1, value, false); + if (flag3) + { + TypeModel.ThrowUnexpectedType(type); + } + } + } + + public void Serialize(Stream dest, object value) + { + this.Serialize(dest, value, null); + } + + public void Serialize(Stream dest, object value, SerializationContext context) + { + using (ProtoWriter protoWriter = new ProtoWriter(dest, this, context)) + { + protoWriter.SetRootObject(value); + this.SerializeCore(protoWriter, value); + protoWriter.Close(); + } + } + + public void Serialize(ProtoWriter dest, object value) + { + bool flag = dest == null; + if (flag) + { + throw new ArgumentNullException("dest"); + } + dest.CheckDepthFlushlock(); + dest.SetRootObject(value); + this.SerializeCore(dest, value); + dest.CheckDepthFlushlock(); + ProtoWriter.Flush(dest); + } + + public object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int fieldNumber) + { + int num; + return this.DeserializeWithLengthPrefix(source, value, type, style, fieldNumber, null, out num); + } + + public object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver) + { + int num; + return this.DeserializeWithLengthPrefix(source, value, type, style, expectedField, resolver, out num); + } + + public object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead) + { + bool flag; + return this.DeserializeWithLengthPrefix(source, value, type, style, expectedField, resolver, out bytesRead, out flag, null); + } + + private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context) + { + haveObject = false; + bytesRead = 0; + bool flag = type == null && (style != PrefixStyle.Base128 || resolver == null); + if (flag) + { + throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver"); + } + for (;;) + { + bool flag2 = expectedField > 0 || resolver != null; + int num2; + int num3; + int num = ProtoReader.ReadLengthPrefix(source, flag2, style, out num2, out num3); + bool flag3 = num3 == 0; + if (flag3) + { + break; + } + bytesRead += num3; + bool flag4 = num < 0; + if (flag4) + { + goto Block_6; + } + bool flag5; + if (style != PrefixStyle.Base128) + { + flag5 = false; + } + else + { + bool flag6 = flag2 && expectedField == 0 && type == null && resolver != null; + if (flag6) + { + type = resolver(num2); + flag5 = (type == null); + } + else + { + flag5 = (expectedField != num2); + } + } + bool flag7 = flag5; + if (flag7) + { + bool flag8 = num == int.MaxValue; + if (flag8) + { + goto Block_13; + } + ProtoReader.Seek(source, num, null); + bytesRead += num; + } + if (!flag5) + { + goto Block_14; + } + } + return value; + Block_6: + return value; + Block_13: + throw new InvalidOperationException(); + Block_14: + ProtoReader protoReader = null; + object result; + try + { + int num = 0;//! + //int num;//! + protoReader = ProtoReader.Create(source, this, context, num); + int key = this.GetKey(ref type); + bool flag9 = key >= 0 && !Helpers.IsEnum(type); + if (flag9) + { + value = this.Deserialize(key, value, protoReader); + } + else + { + bool flag10 = !this.TryDeserializeAuxiliaryType(protoReader, DataFormat.Default, 1, type, ref value, true, false, true, false) && num != 0; + if (flag10) + { + TypeModel.ThrowUnexpectedType(type); + } + } + bytesRead += protoReader.Position; + haveObject = true; + result = value; + } + finally + { + ProtoReader.Recycle(protoReader); + } + return result; + } + + public IEnumerable DeserializeItems(Stream source, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver) + { + return this.DeserializeItems(source, type, style, expectedField, resolver, null); + } + + public IEnumerable DeserializeItems(Stream source, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, SerializationContext context) + { + return new TypeModel.DeserializeItemsIterator(this, source, type, style, expectedField, resolver, context); + } + + public IEnumerable DeserializeItems(Stream source, PrefixStyle style, int expectedField) + { + return this.DeserializeItems(source, style, expectedField, null); + } + + public IEnumerable DeserializeItems(Stream source, PrefixStyle style, int expectedField, SerializationContext context) + { + return new TypeModel.DeserializeItemsIterator(this, source, style, expectedField, context); + } + + public void SerializeWithLengthPrefix(Stream dest, object value, Type type, PrefixStyle style, int fieldNumber) + { + this.SerializeWithLengthPrefix(dest, value, type, style, fieldNumber, null); + } + + public void SerializeWithLengthPrefix(Stream dest, object value, Type type, PrefixStyle style, int fieldNumber, SerializationContext context) + { + bool flag = type == null; + if (flag) + { + bool flag2 = value == null; + if (flag2) + { + throw new ArgumentNullException("value"); + } + type = this.MapType(value.GetType()); + } + int key = this.GetKey(ref type); + using (ProtoWriter protoWriter = new ProtoWriter(dest, this, context)) + { + if (style != PrefixStyle.None) + { + if (style - PrefixStyle.Base128 > 2) + { + throw new ArgumentOutOfRangeException("style"); + } + ProtoWriter.WriteObject(value, key, protoWriter, style, fieldNumber); + } + else + { + this.Serialize(key, value, protoWriter); + } + protoWriter.Close(); + } + } + + public object Deserialize(Stream source, object value, Type type) + { + return this.Deserialize(source, value, type, null); + } + + public object Deserialize(Stream source, object value, Type type, SerializationContext context) + { + bool noAutoCreate = this.PrepareDeserialize(value, ref type); + ProtoReader protoReader = null; + object result; + try + { + protoReader = ProtoReader.Create(source, this, context, -1); + bool flag = value != null; + if (flag) + { + protoReader.SetRootObject(value); + } + object obj = this.DeserializeCore(protoReader, type, value, noAutoCreate); + protoReader.CheckFullyConsumed(); + result = obj; + } + finally + { + ProtoReader.Recycle(protoReader); + } + return result; + } + + private bool PrepareDeserialize(object value, ref Type type) + { + bool flag = type == null; + if (flag) + { + bool flag2 = value == null; + if (flag2) + { + throw new ArgumentNullException("type"); + } + type = this.MapType(value.GetType()); + } + bool result = true; + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag3 = underlyingType != null; + if (flag3) + { + type = underlyingType; + result = false; + } + return result; + } + + public object Deserialize(Stream source, object value, Type type, int length) + { + return this.Deserialize(source, value, type, length, null); + } + + public object Deserialize(Stream source, object value, Type type, int length, SerializationContext context) + { + bool noAutoCreate = this.PrepareDeserialize(value, ref type); + ProtoReader protoReader = null; + object result; + try + { + protoReader = ProtoReader.Create(source, this, context, length); + bool flag = value != null; + if (flag) + { + protoReader.SetRootObject(value); + } + object obj = this.DeserializeCore(protoReader, type, value, noAutoCreate); + protoReader.CheckFullyConsumed(); + result = obj; + } + finally + { + ProtoReader.Recycle(protoReader); + } + return result; + } + + public object Deserialize(ProtoReader source, object value, Type type) + { + bool flag = source == null; + if (flag) + { + throw new ArgumentNullException("source"); + } + bool noAutoCreate = this.PrepareDeserialize(value, ref type); + bool flag2 = value != null; + if (flag2) + { + source.SetRootObject(value); + } + object result = this.DeserializeCore(source, type, value, noAutoCreate); + source.CheckFullyConsumed(); + return result; + } + + private object DeserializeCore(ProtoReader reader, Type type, object value, bool noAutoCreate) + { + int key = this.GetKey(ref type); + bool flag = key >= 0 && !Helpers.IsEnum(type); + object result; + if (flag) + { + result = this.Deserialize(key, value, reader); + } + else + { + this.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, noAutoCreate, false); + result = value; + } + return result; + } + + internal static MethodInfo ResolveListAdd(TypeModel model, Type listType, Type itemType, out bool isList) + { + isList = model.MapType(TypeModel.ilist).IsAssignableFrom(listType); + Type[] array = new Type[] + { + itemType + }; + MethodInfo instanceMethod = Helpers.GetInstanceMethod(listType, "Add", array); + bool flag = instanceMethod == null; + if (flag) + { + bool flag2 = listType.IsInterface && listType == model.MapType(typeof(IEnumerable<>)).MakeGenericType(array); + Type type = model.MapType(typeof(ICollection<>)).MakeGenericType(array); + bool flag3 = flag2 || type.IsAssignableFrom(listType); + if (flag3) + { + instanceMethod = Helpers.GetInstanceMethod(type, "Add", array); + } + } + bool flag4 = instanceMethod == null; + if (flag4) + { + foreach (Type type2 in listType.GetInterfaces()) + { + bool flag5 = type2.Name == "IProducerConsumerCollection`1" && type2.IsGenericType && type2.GetGenericTypeDefinition().FullName == "System.Collections.Concurrent.IProducerConsumerCollection`1"; + if (flag5) + { + instanceMethod = Helpers.GetInstanceMethod(type2, "TryAdd", array); + bool flag6 = instanceMethod != null; + if (flag6) + { + break; + } + } + } + } + bool flag7 = instanceMethod == null; + if (flag7) + { + array[0] = model.MapType(typeof(object)); + instanceMethod = Helpers.GetInstanceMethod(listType, "Add", array); + } + bool flag8 = instanceMethod == null & isList; + if (flag8) + { + instanceMethod = Helpers.GetInstanceMethod(model.MapType(TypeModel.ilist), "Add", array); + } + return instanceMethod; + } + + internal static Type GetListItemType(TypeModel model, Type listType) + { + Helpers.DebugAssert(listType != null); + bool flag = listType == model.MapType(typeof(string)) || listType.IsArray || !model.MapType(typeof(IEnumerable)).IsAssignableFrom(listType); + Type result; + if (flag) + { + result = null; + } + else + { + BasicList basicList = new BasicList(); + foreach (MethodInfo methodInfo in listType.GetMethods()) + { + bool flag2 = methodInfo.IsStatic || methodInfo.Name != "Add"; + if (!flag2) + { + ParameterInfo[] parameters = methodInfo.GetParameters(); + Type parameterType = null; + bool flag3 = parameters.Length == 1 && !basicList.Contains(parameterType = parameters[0].ParameterType); + if (flag3) + { + basicList.Add(parameterType); + } + } + } + string name = listType.Name; + bool flag4 = name != null && (name.IndexOf("Queue") >= 0 || name.IndexOf("Stack") >= 0); + bool flag5 = !flag4; + if (flag5) + { + TypeModel.TestEnumerableListPatterns(model, basicList, listType); + foreach (Type iType in listType.GetInterfaces()) + { + TypeModel.TestEnumerableListPatterns(model, basicList, iType); + } + } + foreach (PropertyInfo propertyInfo in listType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) + { + bool flag6 = propertyInfo.Name != "Item" || basicList.Contains(propertyInfo.PropertyType); + if (!flag6) + { + ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters(); + bool flag7 = indexParameters.Length != 1 || indexParameters[0].ParameterType != model.MapType(typeof(int)); + if (!flag7) + { + basicList.Add(propertyInfo.PropertyType); + } + } + } + switch (basicList.Count) + { + case 0: + return null; + case 1: + return (Type)basicList[0]; + case 2: + { + bool flag8 = TypeModel.CheckDictionaryAccessors(model, (Type)basicList[0], (Type)basicList[1]); + if (flag8) + { + return (Type)basicList[0]; + } + bool flag9 = TypeModel.CheckDictionaryAccessors(model, (Type)basicList[1], (Type)basicList[0]); + if (flag9) + { + return (Type)basicList[1]; + } + break; + } + } + result = null; + } + return result; + } + + private static void TestEnumerableListPatterns(TypeModel model, BasicList candidates, Type iType) + { + bool isGenericType = iType.IsGenericType; + if (isGenericType) + { + Type genericTypeDefinition = iType.GetGenericTypeDefinition(); + bool flag = genericTypeDefinition == model.MapType(typeof(IEnumerable<>)) || genericTypeDefinition == model.MapType(typeof(ICollection<>)) || genericTypeDefinition.FullName == "System.Collections.Concurrent.IProducerConsumerCollection`1"; + if (flag) + { + Type[] genericArguments = iType.GetGenericArguments(); + bool flag2 = !candidates.Contains(genericArguments[0]); + if (flag2) + { + candidates.Add(genericArguments[0]); + } + } + } + } + + private static bool CheckDictionaryAccessors(TypeModel model, Type pair, Type value) + { + return pair.IsGenericType && pair.GetGenericTypeDefinition() == model.MapType(typeof(KeyValuePair<, >)) && pair.GetGenericArguments()[1] == value; + } + + private bool TryDeserializeList(TypeModel model, ProtoReader reader, DataFormat format, int tag, Type listType, Type itemType, ref object value) + { + bool flag; + MethodInfo methodInfo = TypeModel.ResolveListAdd(model, listType, itemType, out flag); + bool flag2 = methodInfo == null; + if (flag2) + { + throw new NotSupportedException("Unknown list variant: " + listType.FullName); + } + bool result = false; + object obj = null; + IList list = value as IList; + object[] array = flag ? null : ProtoDecoratorBase.s_argsRead; + BasicList basicList = listType.IsArray ? new BasicList() : null; + while (this.TryDeserializeAuxiliaryType(reader, format, tag, itemType, ref obj, true, true, true, true)) + { + result = true; + bool flag3 = value == null && basicList == null; + if (flag3) + { + value = TypeModel.CreateListInstance(listType, itemType); + list = (value as IList); + } + bool flag4 = list != null; + if (flag4) + { + list.Add(obj); + } + else + { + bool flag5 = basicList != null; + if (flag5) + { + basicList.Add(obj); + } + else + { + array[0] = obj; + methodInfo.Invoke(value, array); + } + } + obj = null; + } + bool flag6 = basicList != null; + if (flag6) + { + bool flag7 = value != null; + if (flag7) + { + bool flag8 = basicList.Count == 0; + if (!flag8) + { + Array array2 = (Array)value; + Array array3 = Array.CreateInstance(itemType, array2.Length + basicList.Count); + Array.Copy(array2, array3, array2.Length); + basicList.CopyTo(array3, array2.Length); + value = array3; + } + } + else + { + Array array3 = Array.CreateInstance(itemType, basicList.Count); + basicList.CopyTo(array3, 0); + value = array3; + } + } + return result; + } + + private static object CreateListInstance(Type listType, Type itemType) + { + Type type = listType; + bool isArray = listType.IsArray; + object result; + if (isArray) + { + result = Array.CreateInstance(itemType, 0); + } + else + { + bool flag = !listType.IsClass || listType.IsAbstract || Helpers.GetConstructor(listType, Helpers.EmptyTypes, true) == null; + if (flag) + { + bool flag2 = false; + string fullName; + bool flag3 = listType.IsInterface && (fullName = listType.FullName) != null && fullName.IndexOf("Dictionary") >= 0; + if (flag3) + { + bool flag4 = listType.IsGenericType && listType.GetGenericTypeDefinition() == typeof(IDictionary<, >); + if (flag4) + { + Type[] genericArguments = listType.GetGenericArguments(); + type = typeof(Dictionary<, >).MakeGenericType(genericArguments); + flag2 = true; + } + bool flag5 = !flag2 && listType == typeof(IDictionary); + if (flag5) + { + type = typeof(Hashtable); + flag2 = true; + } + } + bool flag6 = !flag2; + if (flag6) + { + type = typeof(List<>).MakeGenericType(new Type[] + { + itemType + }); + flag2 = true; + } + bool flag7 = !flag2; + if (flag7) + { + type = typeof(ArrayList); + } + } + result = Activator.CreateInstance(type); + } + return result; + } + + internal bool TryDeserializeAuxiliaryType(ProtoReader reader, DataFormat format, int tag, Type type, ref object value, bool skipOtherFields, bool asListItem, bool autoCreate, bool insideList) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + ProtoTypeCode typeCode = Helpers.GetTypeCode(type); + int num; + WireType wireType = this.GetWireType(typeCode, format, ref type, out num); + bool flag2 = false; + bool flag3 = wireType == WireType.None; + if (flag3) + { + Type type2 = TypeModel.GetListItemType(this, type); + bool flag4 = type2 == null && type.IsArray && type.GetArrayRank() == 1 && type != typeof(byte[]); + if (flag4) + { + type2 = type.GetElementType(); + } + bool flag5 = type2 != null; + if (flag5) + { + if (insideList) + { + throw TypeModel.CreateNestedListsNotSupported(); + } + flag2 = this.TryDeserializeList(this, reader, format, tag, type, type2, ref value); + bool flag6 = !flag2 && autoCreate; + if (flag6) + { + value = TypeModel.CreateListInstance(type, type2); + } + return flag2; + } + else + { + TypeModel.ThrowUnexpectedType(type); + } + } + int num2; + for (;;) + { + bool flag7 = flag2 && asListItem; + if (flag7) + { + break; + } + num2 = reader.ReadFieldHeader(); + bool flag8 = num2 <= 0; + if (flag8) + { + break; + } + bool flag9 = num2 != tag; + if (flag9) + { + if (!skipOtherFields) + { + goto IL_12E; + } + reader.SkipField(); + } + else + { + flag2 = true; + reader.Hint(wireType); + bool flag10 = num >= 0; + if (flag10) + { + WireType wireType2 = wireType; + if (wireType2 - WireType.String > 1) + { + value = this.Deserialize(num, value, reader); + } + else + { + SubItemToken token = ProtoReader.StartSubItem(reader); + value = this.Deserialize(num, value, reader); + ProtoReader.EndSubItem(token, reader); + } + } + else + { + ProtoTypeCode protoTypeCode = typeCode; + switch (protoTypeCode) + { + case ProtoTypeCode.Boolean: + value = reader.ReadBoolean(); + break; + case ProtoTypeCode.Char: + value = (char)reader.ReadUInt16(); + break; + case ProtoTypeCode.SByte: + value = reader.ReadSByte(); + break; + case ProtoTypeCode.Byte: + value = reader.ReadByte(); + break; + case ProtoTypeCode.Int16: + value = reader.ReadInt16(); + break; + case ProtoTypeCode.UInt16: + value = reader.ReadUInt16(); + break; + case ProtoTypeCode.Int32: + value = reader.ReadInt32(); + break; + case ProtoTypeCode.UInt32: + value = reader.ReadUInt32(); + break; + case ProtoTypeCode.Int64: + value = reader.ReadInt64(); + break; + case ProtoTypeCode.UInt64: + value = reader.ReadUInt64(); + break; + case ProtoTypeCode.Single: + value = reader.ReadSingle(); + break; + case ProtoTypeCode.Double: + value = reader.ReadDouble(); + break; + case ProtoTypeCode.Decimal: + value = BclHelpers.ReadDecimal(reader); + break; + case ProtoTypeCode.DateTime: + value = BclHelpers.ReadDateTime(reader); + break; + case (ProtoTypeCode)17: + break; + case ProtoTypeCode.String: + value = reader.ReadString(); + break; + default: + switch (protoTypeCode) + { + case ProtoTypeCode.TimeSpan: + value = BclHelpers.ReadTimeSpan(reader); + break; + case ProtoTypeCode.ByteArray: + value = ProtoReader.AppendBytes((byte[])value, reader); + break; + case ProtoTypeCode.Guid: + value = BclHelpers.ReadGuid(reader); + break; + case ProtoTypeCode.Uri: + value = new Uri(reader.ReadString()); + break; + } + break; + } + } + } + } + goto IL_375; + IL_12E: + throw ProtoReader.AddErrorData(new InvalidOperationException("Expected field " + tag.ToString() + ", but found " + num2.ToString()), reader); + IL_375: + bool flag11 = !flag2 && !asListItem && autoCreate; + if (flag11) + { + bool flag12 = type != typeof(string); + if (flag12) + { + value = Activator.CreateInstance(type); + } + } + return flag2; + } + + public static RuntimeTypeModel Create() + { + return new RuntimeTypeModel(false); + } + + protected internal static Type ResolveProxies(Type type) + { + bool flag = type == null; + Type result; + if (flag) + { + result = null; + } + else + { + bool isGenericParameter = type.IsGenericParameter; + if (isGenericParameter) + { + result = null; + } + else + { + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag2 = underlyingType != null; + if (flag2) + { + result = underlyingType; + } + else + { + string fullName = type.FullName; + bool flag3 = fullName != null && fullName.StartsWith("System.Data.Entity.DynamicProxies."); + if (flag3) + { + result = type.BaseType; + } + else + { + Type[] interfaces = type.GetInterfaces(); + for (int i = 0; i < interfaces.Length; i++) + { + string fullName2 = interfaces[i].FullName; + if (fullName2 == "NHibernate.Proxy.INHibernateProxy" || fullName2 == "NHibernate.Proxy.DynamicProxy.IProxy" || fullName2 == "NHibernate.Intercept.IFieldInterceptorAccessor") + { + return type.BaseType; + } + } + result = null; + } + } + } + } + return result; + } + + public bool IsDefined(Type type) + { + return this.GetKey(ref type) >= 0; + } + + protected internal int GetKey(ref Type type) + { + bool flag = type == null; + int result; + if (flag) + { + result = -1; + } + else + { + int keyImpl = this.GetKeyImpl(type); + bool flag2 = keyImpl < 0; + if (flag2) + { + Type type2 = TypeModel.ResolveProxies(type); + bool flag3 = type2 != null; + if (flag3) + { + type = type2; + keyImpl = this.GetKeyImpl(type); + } + } + result = keyImpl; + } + return result; + } + + protected abstract int GetKeyImpl(Type type); + + protected internal abstract void Serialize(int key, object value, ProtoWriter dest); + + protected internal abstract object Deserialize(int key, object value, ProtoReader source); + + public object DeepClone(object value) + { + bool flag = value == null; + object result; + if (flag) + { + result = null; + } + else + { + Type type = value.GetType(); + int key = this.GetKey(ref type); + bool flag2 = key >= 0 && !Helpers.IsEnum(type); + if (flag2) + { + using (MemoryStream memoryStream = new MemoryStream()) + { + using (ProtoWriter protoWriter = new ProtoWriter(memoryStream, this, null)) + { + protoWriter.SetRootObject(value); + this.Serialize(key, value, protoWriter); + protoWriter.Close(); + } + memoryStream.Position = 0L; + ProtoReader protoReader = null; + try + { + protoReader = ProtoReader.Create(memoryStream, this, null, -1); + return this.Deserialize(key, null, protoReader); + } + finally + { + ProtoReader.Recycle(protoReader); + } + } + } + bool flag3 = type == typeof(byte[]); + if (flag3) + { + byte[] array = (byte[])value; + byte[] array2 = new byte[array.Length]; + Helpers.BlockCopy(array, 0, array2, 0, array.Length); + result = array2; + } + else + { + int num; + bool flag4 = this.GetWireType(Helpers.GetTypeCode(type), DataFormat.Default, ref type, out num) != WireType.None && num < 0; + if (flag4) + { + result = value; + } + else + { + using (MemoryStream memoryStream2 = new MemoryStream()) + { + using (ProtoWriter protoWriter2 = new ProtoWriter(memoryStream2, this, null)) + { + bool flag5 = !this.TrySerializeAuxiliaryType(protoWriter2, type, DataFormat.Default, 1, value, false); + if (flag5) + { + TypeModel.ThrowUnexpectedType(type); + } + protoWriter2.Close(); + } + memoryStream2.Position = 0L; + ProtoReader reader = null; + try + { + reader = ProtoReader.Create(memoryStream2, this, null, -1); + value = null; + this.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false); + result = value; + } + finally + { + ProtoReader.Recycle(reader); + } + } + } + } + } + return result; + } + + protected internal static void ThrowUnexpectedSubtype(Type expected, Type actual) + { + bool flag = expected != TypeModel.ResolveProxies(actual); + if (flag) + { + throw new InvalidOperationException("Unexpected sub-type: " + actual.FullName); + } + } + + protected internal static void ThrowUnexpectedType(Type type) + { + string str = (type == null) ? "(unknown)" : type.FullName; + bool flag = type != null; + if (flag) + { + Type baseType = type.BaseType; + bool flag2 = baseType != null && baseType.IsGenericType && baseType.GetGenericTypeDefinition().Name == "GeneratedMessage`2"; + if (flag2) + { + throw new InvalidOperationException("Are you mixing protobuf-net and protobuf-csharp-port? See http://stackoverflow.com/q/11564914; type: " + str); + } + } + throw new InvalidOperationException("Type is not expected, and no contract can be inferred: " + str); + } + + internal static Exception CreateNestedListsNotSupported() + { + return new NotSupportedException("Nested or jagged lists and arrays are not supported"); + } + + public static void ThrowCannotCreateInstance(Type type) + { + throw new ProtoException("No parameterless constructor found for " + ((type == null) ? "(null)" : type.Name)); + } + + internal static string SerializeType(TypeModel model, Type type) + { + bool flag = model != null; + if (flag) + { + TypeFormatEventHandler dynamicTypeFormatting = model.DynamicTypeFormatting; + bool flag2 = dynamicTypeFormatting != null; + if (flag2) + { + TypeFormatEventArgs typeFormatEventArgs = new TypeFormatEventArgs(type); + dynamicTypeFormatting(model, typeFormatEventArgs); + bool flag3 = !Helpers.IsNullOrEmpty(typeFormatEventArgs.FormattedName); + if (flag3) + { + return typeFormatEventArgs.FormattedName; + } + } + } + return type.AssemblyQualifiedName; + } + + internal static Type DeserializeType(TypeModel model, string value) + { + bool flag = model != null; + if (flag) + { + TypeFormatEventHandler dynamicTypeFormatting = model.DynamicTypeFormatting; + bool flag2 = dynamicTypeFormatting != null; + if (flag2) + { + TypeFormatEventArgs typeFormatEventArgs = new TypeFormatEventArgs(value); + dynamicTypeFormatting(model, typeFormatEventArgs); + bool flag3 = typeFormatEventArgs.Type != null; + if (flag3) + { + return typeFormatEventArgs.Type; + } + } + } + return Type.GetType(value); + } + + public bool CanSerializeContractType(Type type) + { + return this.CanSerialize(type, false, true, true); + } + + public bool CanSerialize(Type type) + { + return this.CanSerialize(type, true, true, true); + } + + public bool CanSerializeBasicType(Type type) + { + return this.CanSerialize(type, true, false, true); + } + + private bool CanSerialize(Type type, bool allowBasic, bool allowContract, bool allowLists) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag2 = underlyingType != null; + if (flag2) + { + type = underlyingType; + } + ProtoTypeCode typeCode = Helpers.GetTypeCode(type); + ProtoTypeCode protoTypeCode = typeCode; + bool result; + if (protoTypeCode > ProtoTypeCode.Unknown) + { + result = allowBasic; + } + else + { + int key = this.GetKey(ref type); + bool flag3 = key >= 0; + if (flag3) + { + result = allowContract; + } + else + { + if (allowLists) + { + Type type2 = null; + bool isArray = type.IsArray; + if (isArray) + { + bool flag4 = type.GetArrayRank() == 1; + if (flag4) + { + type2 = type.GetElementType(); + } + } + else + { + type2 = TypeModel.GetListItemType(this, type); + } + bool flag5 = type2 != null; + if (flag5) + { + return this.CanSerialize(type2, allowBasic, allowContract, false); + } + } + result = false; + } + } + return result; + } + + public virtual string GetSchema(Type type) + { + throw new NotSupportedException(); + } + + internal virtual Type GetType(string fullName, Assembly context) + { + return TypeModel.ResolveKnownType(fullName, this, context); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + internal static Type ResolveKnownType(string name, TypeModel model, Assembly assembly) + { + bool flag = Helpers.IsNullOrEmpty(name); + Type result; + if (flag) + { + result = null; + } + else + { + try + { + Type type = Type.GetType(name); + bool flag2 = type != null; + if (flag2) + { + return type; + } + } + catch + { + } + try + { + int num = name.IndexOf(','); + string name2 = ((num > 0) ? name.Substring(0, num) : name).Trim(); + bool flag3 = assembly == null; + if (flag3) + { + assembly = Assembly.GetCallingAssembly(); + } + Type type2 = (assembly == null) ? null : assembly.GetType(name2); + bool flag4 = type2 != null; + if (flag4) + { + return type2; + } + } + catch + { + } + result = null; + } + return result; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs.meta new file mode 100644 index 00000000..71fa0af1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/TypeModel.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: dbb3d0ca7c570e0439827efde10650ea +timeCreated: 1611404654 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs new file mode 100644 index 00000000..ec50b41a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs @@ -0,0 +1,808 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Globalization; +using System.Reflection; +using ProtoBuf.Serializers; + +namespace ProtoBuf.Meta +{ + public class ValueMember + { + public int FieldNumber + { + get + { + return this.fieldNumber; + } + } + + public MemberInfo Member + { + get + { + return this.member; + } + } + + public Type ItemType + { + get + { + return this.itemType; + } + } + + public Type MemberType + { + get + { + return this.memberType; + } + } + + public Type DefaultType + { + get + { + return this.defaultType; + } + } + + public Type ParentType + { + get + { + return this.parentType; + } + } + + public object DefaultValue + { + get + { + return this.defaultValue; + } + set + { + this.ThrowIfFrozen(); + this.defaultValue = value; + } + } + + internal IProtoSerializer Serializer + { + get + { + bool flag = this.serializer == null; + if (flag) + { + this.serializer = this.BuildSerializer(); + } + return this.serializer; + } + } + + public DataFormat DataFormat + { + get + { + return this.dataFormat; + } + set + { + this.ThrowIfFrozen(); + this.dataFormat = value; + } + } + + public bool IsStrict + { + get + { + return this.HasFlag(1); + } + set + { + this.SetFlag(1, value, true); + } + } + + public bool IsPacked + { + get + { + return this.HasFlag(2); + } + set + { + this.SetFlag(2, value, true); + } + } + + public bool OverwriteList + { + get + { + return this.HasFlag(8); + } + set + { + this.SetFlag(8, value, true); + } + } + + public bool IsRequired + { + get + { + return this.HasFlag(4); + } + set + { + this.SetFlag(4, value, true); + } + } + + public bool AsReference + { + get + { + return this.asReference; + } + set + { + this.ThrowIfFrozen(); + this.asReference = value; + } + } + + public bool DynamicType + { + get + { + return this.dynamicType; + } + set + { + this.ThrowIfFrozen(); + this.dynamicType = value; + } + } + + public string Name + { + get + { + return Helpers.IsNullOrEmpty(this.name) ? this.member.Name : this.name; + } + } + + public bool SupportNull + { + get + { + return this.HasFlag(16); + } + set + { + this.SetFlag(16, value, true); + } + } + + private readonly int fieldNumber; + + private readonly MemberInfo member; + + private readonly Type parentType; + + private readonly Type itemType; + + private readonly Type defaultType; + + private readonly Type memberType; + + private object defaultValue; + + private readonly RuntimeTypeModel model; + + private IProtoSerializer serializer; + + private DataFormat dataFormat; + + private bool asReference; + + private bool dynamicType; + + private MethodInfo getSpecified; + + private MethodInfo setSpecified; + + private string name; + + private const byte OPTIONS_IsStrict = 1; + + private const byte OPTIONS_IsPacked = 2; + + private const byte OPTIONS_IsRequired = 4; + + private const byte OPTIONS_OverwriteList = 8; + + private const byte OPTIONS_SupportNull = 16; + + private byte flags; + + internal sealed class Comparer : IComparer, IComparer + { + public static readonly ValueMember.Comparer Default = new ValueMember.Comparer(); + + public int Compare(object x, object y) + { + return this.Compare(x as ValueMember, y as ValueMember); + } + + public int Compare(ValueMember x, ValueMember y) + { + bool flag = x == y; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x == null; + if (flag2) + { + result = -1; + } + else + { + bool flag3 = y == null; + if (flag3) + { + result = 1; + } + else + { + result = x.FieldNumber.CompareTo(y.FieldNumber); + } + } + } + return result; + } + } + + public ValueMember(RuntimeTypeModel model, Type parentType, int fieldNumber, MemberInfo member, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat, object defaultValue) : this(model, fieldNumber, memberType, itemType, defaultType, dataFormat) + { + bool flag = member == null; + if (flag) + { + throw new ArgumentNullException("member"); + } + bool flag2 = parentType == null; + if (flag2) + { + throw new ArgumentNullException("parentType"); + } + bool flag3 = fieldNumber < 1 && !Helpers.IsEnum(parentType); + if (flag3) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + this.member = member; + this.parentType = parentType; + bool flag4 = fieldNumber < 1 && !Helpers.IsEnum(parentType); + if (flag4) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + bool flag5 = defaultValue != null && model.MapType(defaultValue.GetType()) != memberType; + if (flag5) + { + defaultValue = ValueMember.ParseDefaultValue(memberType, defaultValue); + } + this.defaultValue = defaultValue; + MetaType metaType = model.FindWithoutAdd(memberType); + bool flag6 = metaType != null; + if (flag6) + { + this.asReference = metaType.AsReferenceDefault; + } + else + { + this.asReference = MetaType.GetAsReferenceDefault(model, memberType); + } + } + + internal ValueMember(RuntimeTypeModel model, int fieldNumber, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat) + { + bool flag = memberType == null; + if (flag) + { + throw new ArgumentNullException("memberType"); + } + bool flag2 = model == null; + if (flag2) + { + throw new ArgumentNullException("model"); + } + this.fieldNumber = fieldNumber; + this.memberType = memberType; + this.itemType = itemType; + this.defaultType = defaultType; + this.model = model; + this.dataFormat = dataFormat; + } + + internal object GetRawEnumValue() + { + return ((FieldInfo)this.member).GetRawConstantValue(); + } + + private static object ParseDefaultValue(Type type, object value) + { + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag = underlyingType != null; + if (flag) + { + type = underlyingType; + } + bool flag2 = value is string; + if (flag2) + { + string text = (string)value; + bool flag3 = Helpers.IsEnum(type); + if (flag3) + { + return Helpers.ParseEnum(type, text); + } + ProtoTypeCode typeCode = Helpers.GetTypeCode(type); + switch (typeCode) + { + case ProtoTypeCode.Boolean: + return bool.Parse(text); + case ProtoTypeCode.Char: + { + bool flag4 = text.Length == 1; + if (flag4) + { + return text[0]; + } + throw new FormatException("Single character expected: \"" + text + "\""); + } + case ProtoTypeCode.SByte: + return sbyte.Parse(text, NumberStyles.Integer, CultureInfo.InvariantCulture); + case ProtoTypeCode.Byte: + return byte.Parse(text, NumberStyles.Integer, CultureInfo.InvariantCulture); + case ProtoTypeCode.Int16: + return short.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.UInt16: + return ushort.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.Int32: + return int.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.UInt32: + return uint.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.Int64: + return long.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.UInt64: + return ulong.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.Single: + return float.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.Double: + return double.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.Decimal: + return decimal.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture); + case ProtoTypeCode.DateTime: + return DateTime.Parse(text, CultureInfo.InvariantCulture); + case (ProtoTypeCode)17: + break; + case ProtoTypeCode.String: + return text; + default: + switch (typeCode) + { + case ProtoTypeCode.TimeSpan: + return TimeSpan.Parse(text); + case ProtoTypeCode.Guid: + return new Guid(text); + case ProtoTypeCode.Uri: + return text; + } + break; + } + } + bool flag5 = Helpers.IsEnum(type); + object result; + if (flag5) + { + result = Enum.ToObject(type, value); + } + else + { + result = Convert.ChangeType(value, type, CultureInfo.InvariantCulture); + } + return result; + } + + public void SetSpecified(MethodInfo getSpecified, MethodInfo setSpecified) + { + bool flag = getSpecified != null; + if (flag) + { + bool flag2 = getSpecified.ReturnType != this.model.MapType(typeof(bool)) || getSpecified.IsStatic || getSpecified.GetParameters().Length != 0; + if (flag2) + { + throw new ArgumentException("Invalid pattern for checking member-specified", "getSpecified"); + } + } + bool flag3 = setSpecified != null; + if (flag3) + { + ParameterInfo[] parameters; + bool flag4 = setSpecified.ReturnType != this.model.MapType(typeof(void)) || setSpecified.IsStatic || (parameters = setSpecified.GetParameters()).Length != 1 || parameters[0].ParameterType != this.model.MapType(typeof(bool)); + if (flag4) + { + throw new ArgumentException("Invalid pattern for setting member-specified", "setSpecified"); + } + } + this.ThrowIfFrozen(); + this.getSpecified = getSpecified; + this.setSpecified = setSpecified; + } + + private void ThrowIfFrozen() + { + bool flag = this.serializer != null; + if (flag) + { + throw new InvalidOperationException("The type cannot be changed once a serializer has been generated"); + } + } + + private IProtoSerializer BuildSerializer() + { + int opaqueToken = 0; + IProtoSerializer result; + try + { + this.model.TakeLock(ref opaqueToken); + Type type = (this.itemType == null) ? this.memberType : this.itemType; + WireType wireType; + IProtoSerializer protoSerializer = ValueMember.TryGetCoreSerializer(this.model, this.dataFormat, type, out wireType, this.asReference, this.dynamicType, this.OverwriteList, true); + bool flag = protoSerializer == null; + if (flag) + { + throw new InvalidOperationException("No serializer defined for type: " + type.FullName); + } + bool flag2 = this.itemType != null && this.SupportNull; + if (flag2) + { + bool isPacked = this.IsPacked; + if (isPacked) + { + throw new NotSupportedException("Packed encodings cannot support null values"); + } + protoSerializer = new TagDecorator(1, wireType, this.IsStrict, protoSerializer); + protoSerializer = new NullDecorator(this.model, protoSerializer); + protoSerializer = new TagDecorator(this.fieldNumber, WireType.StartGroup, false, protoSerializer); + } + else + { + protoSerializer = new TagDecorator(this.fieldNumber, wireType, this.IsStrict, protoSerializer); + } + bool flag3 = this.itemType != null; + if (flag3) + { + Type type2 = this.SupportNull ? this.itemType : (Helpers.GetUnderlyingType(this.itemType) ?? this.itemType); + Helpers.DebugAssert(type2 == protoSerializer.ExpectedType, "Wrong type in the tail; expected {0}, received {1}", new object[] + { + protoSerializer.ExpectedType, + type2 + }); + bool isArray = this.memberType.IsArray; + if (isArray) + { + protoSerializer = new ArrayDecorator(this.model, protoSerializer, this.fieldNumber, this.IsPacked, wireType, this.memberType, this.OverwriteList, this.SupportNull); + } + else + { + protoSerializer = ListDecorator.Create(this.model, this.memberType, this.defaultType, protoSerializer, this.fieldNumber, this.IsPacked, wireType, this.member != null && PropertyDecorator.CanWrite(this.model, this.member), this.OverwriteList, this.SupportNull); + } + } + else + { + bool flag4 = this.defaultValue != null && !this.IsRequired && this.getSpecified == null; + if (flag4) + { + protoSerializer = new DefaultValueDecorator(this.model, this.defaultValue, protoSerializer); + } + } + bool flag5 = this.memberType == this.model.MapType(typeof(Uri)); + if (flag5) + { + protoSerializer = new UriDecorator(this.model, protoSerializer); + } + bool flag6 = this.member != null; + if (flag6) + { + PropertyInfo propertyInfo = this.member as PropertyInfo; + bool flag7 = propertyInfo != null; + if (flag7) + { + protoSerializer = new PropertyDecorator(this.model, this.parentType, (PropertyInfo)this.member, protoSerializer); + } + else + { + FieldInfo fieldInfo = this.member as FieldInfo; + bool flag8 = fieldInfo != null; + if (!flag8) + { + throw new InvalidOperationException(); + } + protoSerializer = new FieldDecorator(this.parentType, (FieldInfo)this.member, protoSerializer); + } + bool flag9 = this.getSpecified != null || this.setSpecified != null; + if (flag9) + { + protoSerializer = new MemberSpecifiedDecorator(this.getSpecified, this.setSpecified, protoSerializer); + } + } + result = protoSerializer; + } + finally + { + this.model.ReleaseLock(opaqueToken); + } + return result; + } + + private static WireType GetIntWireType(DataFormat format, int width) + { + WireType result; + switch (format) + { + case DataFormat.Default: + case DataFormat.TwosComplement: + result = WireType.Variant; + break; + case DataFormat.ZigZag: + result = WireType.SignedVariant; + break; + case DataFormat.FixedSize: + result = ((width == 32) ? WireType.Fixed32 : WireType.Fixed64); + break; + default: + throw new InvalidOperationException(); + } + return result; + } + + private static WireType GetDateTimeWireType(DataFormat format) + { + switch (format) + { + case DataFormat.Default: + return WireType.String; + case DataFormat.FixedSize: + return WireType.Fixed64; + case DataFormat.Group: + return WireType.StartGroup; + } + throw new InvalidOperationException(); + } + + internal static IProtoSerializer TryGetCoreSerializer(RuntimeTypeModel model, DataFormat dataFormat, Type type, out WireType defaultWireType, bool asReference, bool dynamicType, bool overwriteList, bool allowComplexTypes) + { + Type underlyingType = Helpers.GetUnderlyingType(type); + bool flag = underlyingType != null; + if (flag) + { + type = underlyingType; + } + bool flag2 = Helpers.IsEnum(type); + IProtoSerializer result; + if (flag2) + { + bool flag3 = allowComplexTypes && model != null; + if (flag3) + { + defaultWireType = WireType.Variant; + result = new EnumSerializer(type, model.GetEnumMap(type)); + } + else + { + defaultWireType = WireType.None; + result = null; + } + } + else + { + ProtoTypeCode typeCode = Helpers.GetTypeCode(type); + ProtoTypeCode protoTypeCode = typeCode; + switch (protoTypeCode) + { + case ProtoTypeCode.Boolean: + defaultWireType = WireType.Variant; + return new BooleanSerializer(model); + case ProtoTypeCode.Char: + defaultWireType = WireType.Variant; + return new CharSerializer(model); + case ProtoTypeCode.SByte: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new SByteSerializer(model); + case ProtoTypeCode.Byte: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new ByteSerializer(model); + case ProtoTypeCode.Int16: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new Int16Serializer(model); + case ProtoTypeCode.UInt16: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new UInt16Serializer(model); + case ProtoTypeCode.Int32: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new Int32Serializer(model); + case ProtoTypeCode.UInt32: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 32); + return new UInt32Serializer(model); + case ProtoTypeCode.Int64: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 64); + return new Int64Serializer(model); + case ProtoTypeCode.UInt64: + defaultWireType = ValueMember.GetIntWireType(dataFormat, 64); + return new UInt64Serializer(model); + case ProtoTypeCode.Single: + defaultWireType = WireType.Fixed32; + return new SingleSerializer(model); + case ProtoTypeCode.Double: + defaultWireType = WireType.Fixed64; + return new DoubleSerializer(model); + case ProtoTypeCode.Decimal: + defaultWireType = WireType.String; + return new DecimalSerializer(model); + case ProtoTypeCode.DateTime: + defaultWireType = ValueMember.GetDateTimeWireType(dataFormat); + return new DateTimeSerializer(model); + case (ProtoTypeCode)17: + break; + case ProtoTypeCode.String: + defaultWireType = WireType.String; + if (asReference) + { + return new NetObjectSerializer(model, model.MapType(typeof(string)), 0, BclHelpers.NetObjectOptions.AsReference); + } + return new StringSerializer(model); + default: + switch (protoTypeCode) + { + case ProtoTypeCode.TimeSpan: + defaultWireType = ValueMember.GetDateTimeWireType(dataFormat); + return new TimeSpanSerializer(model); + case ProtoTypeCode.ByteArray: + defaultWireType = WireType.String; + return new BlobSerializer(model, overwriteList); + case ProtoTypeCode.Guid: + defaultWireType = WireType.String; + return new GuidSerializer(model); + case ProtoTypeCode.Uri: + defaultWireType = WireType.String; + return new StringSerializer(model); + case ProtoTypeCode.Type: + defaultWireType = WireType.String; + return new SystemTypeSerializer(model); + } + break; + } + IProtoSerializer protoSerializer = model.AllowParseableTypes ? ParseableSerializer.TryCreate(type, model) : null; + bool flag4 = protoSerializer != null; + if (flag4) + { + defaultWireType = WireType.String; + result = protoSerializer; + } + else + { + bool flag5 = allowComplexTypes && model != null; + if (flag5) + { + int key = model.GetKey(type, false, true); + bool flag6 = asReference || dynamicType; + if (flag6) + { + defaultWireType = ((dataFormat == DataFormat.Group) ? WireType.StartGroup : WireType.String); + BclHelpers.NetObjectOptions netObjectOptions = BclHelpers.NetObjectOptions.None; + if (asReference) + { + netObjectOptions |= BclHelpers.NetObjectOptions.AsReference; + } + if (dynamicType) + { + netObjectOptions |= BclHelpers.NetObjectOptions.DynamicType; + } + bool flag7 = key >= 0; + if (flag7) + { + bool flag8 = asReference && Helpers.IsValueType(type); + if (flag8) + { + string text = "AsReference cannot be used with value-types"; + bool flag9 = type.Name == "KeyValuePair`2"; + if (flag9) + { + text += "; please see http://stackoverflow.com/q/14436606/"; + } + else + { + text = text + ": " + type.FullName; + } + throw new InvalidOperationException(text); + } + MetaType metaType = model[type]; + bool flag10 = asReference && metaType.IsAutoTuple; + if (flag10) + { + netObjectOptions |= BclHelpers.NetObjectOptions.LateSet; + } + bool useConstructor = metaType.UseConstructor; + if (useConstructor) + { + netObjectOptions |= BclHelpers.NetObjectOptions.UseConstructor; + } + } + return new NetObjectSerializer(model, type, key, netObjectOptions); + } + bool flag11 = key >= 0; + if (flag11) + { + defaultWireType = ((dataFormat == DataFormat.Group) ? WireType.StartGroup : WireType.String); + return new SubItemSerializer(type, key, model[type], true); + } + } + defaultWireType = WireType.None; + result = null; + } + } + return result; + } + + internal void SetName(string name) + { + this.ThrowIfFrozen(); + this.name = name; + } + + private bool HasFlag(byte flag) + { + return (this.flags & flag) == flag; + } + + private void SetFlag(byte flag, bool value, bool throwIfFrozen) + { + bool flag2 = throwIfFrozen && this.HasFlag(flag) != value; + if (flag2) + { + this.ThrowIfFrozen(); + } + if (value) + { + this.flags |= flag; + } + else + { + this.flags &= (byte) ~flag; + } + } + + internal string GetSchemaTypeName(bool applyNetObjectProxy, ref bool requiresBclImport) + { + Type type = this.ItemType; + bool flag = type == null; + if (flag) + { + type = this.MemberType; + } + return this.model.GetSchemaTypeName(type, this.DataFormat, applyNetObjectProxy && this.asReference, applyNetObjectProxy && this.dynamicType, ref requiresBclImport); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs.meta new file mode 100644 index 00000000..a92dffc3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Meta/ValueMember.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 20dcdd655bb536f4198cd99e27b58ded +timeCreated: 1611403409 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs new file mode 100644 index 00000000..be43372e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs @@ -0,0 +1,256 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + internal sealed class NetObjectCache + { + private MutableList List + { + get + { + bool flag = this.underlyingList == null; + if (flag) + { + this.underlyingList = new MutableList(); + } + return this.underlyingList; + } + } + + internal const int Root = 0; + + private MutableList underlyingList; + + private object rootObject; + + private int trapStartIndex; + + private Dictionary stringKeys; + + private Dictionary objectKeys; + + private sealed class ReferenceComparer : IEqualityComparer + { + public static readonly NetObjectCache.ReferenceComparer Default = new NetObjectCache.ReferenceComparer(); + + private ReferenceComparer() + { + } + + bool IEqualityComparer.Equals(object x, object y) + { + return x == y; + } + + int IEqualityComparer.GetHashCode(object obj) + { + return RuntimeHelpers.GetHashCode(obj); + } + } + + internal object GetKeyedObject(int key) + { + bool flag = key-- == 0; + object result; + if (flag) + { + bool flag2 = this.rootObject == null; + if (flag2) + { + throw new ProtoException("No root object assigned"); + } + result = this.rootObject; + } + else + { + BasicList list = this.List; + bool flag3 = key < 0 || key >= list.Count; + if (flag3) + { + Helpers.DebugWriteLine("Missing key: " + key); + throw new ProtoException("Internal error; a missing key occurred"); + } + object obj = list[key]; + bool flag4 = obj == null; + if (flag4) + { + throw new ProtoException("A deferred key does not have a value yet"); + } + result = obj; + } + return result; + } + + internal void SetKeyedObject(int key, object value) + { + bool flag = key-- == 0; + if (flag) + { + bool flag2 = value == null; + if (flag2) + { + throw new ArgumentNullException("value"); + } + bool flag3 = this.rootObject != null && this.rootObject != value; + if (flag3) + { + throw new ProtoException("The root object cannot be reassigned"); + } + this.rootObject = value; + } + else + { + MutableList list = this.List; + bool flag4 = key < list.Count; + if (flag4) + { + object obj = list[key]; + bool flag5 = obj == null; + if (flag5) + { + list[key] = value; + } + else + { + bool flag6 = obj != value; + if (flag6) + { + throw new ProtoException("Reference-tracked objects cannot change reference"); + } + } + } + else + { + bool flag7 = key != list.Add(value); + if (flag7) + { + throw new ProtoException("Internal error; a key mismatch occurred"); + } + } + } + } + + internal int AddObjectKey(object value, out bool existing) + { + bool flag = value == null; + if (flag) + { + throw new ArgumentNullException("value"); + } + bool flag2 = value == this.rootObject; + int result; + if (flag2) + { + existing = true; + result = 0; + } + else + { + string text = value as string; + BasicList list = this.List; + bool flag3 = text == null; + int num; + if (flag3) + { + bool flag4 = this.objectKeys == null; + if (flag4) + { + this.objectKeys = new Dictionary(NetObjectCache.ReferenceComparer.Default); + num = -1; + } + else + { + bool flag5 = !this.objectKeys.TryGetValue(value, out num); + if (flag5) + { + num = -1; + } + } + } + else + { + bool flag6 = this.stringKeys == null; + if (flag6) + { + this.stringKeys = new Dictionary(); + num = -1; + } + else + { + bool flag7 = !this.stringKeys.TryGetValue(text, out num); + if (flag7) + { + num = -1; + } + } + } + bool flag8 = !(existing = (num >= 0)); + if (flag8) + { + num = list.Add(value); + bool flag9 = text == null; + if (flag9) + { + this.objectKeys.Add(value, num); + } + else + { + this.stringKeys.Add(text, num); + } + } + result = num + 1; + } + return result; + } + + internal void RegisterTrappedObject(object value) + { + bool flag = this.rootObject == null; + if (flag) + { + this.rootObject = value; + } + else + { + bool flag2 = this.underlyingList != null; + if (flag2) + { + for (int i = this.trapStartIndex; i < this.underlyingList.Count; i++) + { + this.trapStartIndex = i + 1; + bool flag3 = this.underlyingList[i] == null; + if (flag3) + { + this.underlyingList[i] = value; + break; + } + } + } + } + } + + internal void Clear() + { + this.trapStartIndex = 0; + this.rootObject = null; + bool flag = this.underlyingList != null; + if (flag) + { + this.underlyingList.Clear(); + } + bool flag2 = this.stringKeys != null; + if (flag2) + { + this.stringKeys.Clear(); + } + bool flag3 = this.objectKeys != null; + if (flag3) + { + this.objectKeys.Clear(); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs.meta new file mode 100644 index 00000000..64065f90 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/NetObjectCache.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 951673a14fe33ba4cb5b5de3a81e0426 +timeCreated: 1611404179 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs new file mode 100644 index 00000000..d00f4b2e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs @@ -0,0 +1,12 @@ +using System; + +namespace ProtoBuf +{ + public enum PrefixStyle + { + None, + Base128, + Fixed32, + Fixed32BigEndian + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs.meta new file mode 100644 index 00000000..d6e07821 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/PrefixStyle.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: e73cfd14287fd634bae8eb6beeffd66d +timeCreated: 1611404748 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs new file mode 100644 index 00000000..7e79ce17 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs @@ -0,0 +1,11 @@ +using System; +using System.ComponentModel; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)] + [ImmutableObject(true)] + public sealed class ProtoAfterDeserializationAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs.meta new file mode 100644 index 00000000..81dc1255 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterDeserializationAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 85a2871705ad3b84d913daf4c28cf09c +timeCreated: 1611404052 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs new file mode 100644 index 00000000..f6860f7e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs @@ -0,0 +1,11 @@ +using System; +using System.ComponentModel; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)] + [ImmutableObject(true)] + public sealed class ProtoAfterSerializationAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs.meta new file mode 100644 index 00000000..b98aacce --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoAfterSerializationAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c03da7f9ab4fe8047ac8833075c9a435 +timeCreated: 1611404485 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs new file mode 100644 index 00000000..4b1e2da0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs @@ -0,0 +1,11 @@ +using System; +using System.ComponentModel; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)] + [ImmutableObject(true)] + public sealed class ProtoBeforeDeserializationAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs.meta new file mode 100644 index 00000000..562df8c8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeDeserializationAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4642fc0650246b8429aeeee38c911289 +timeCreated: 1611403649 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs new file mode 100644 index 00000000..eeb623d7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs @@ -0,0 +1,11 @@ +using System; +using System.ComponentModel; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)] + [ImmutableObject(true)] + public sealed class ProtoBeforeSerializationAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs.meta new file mode 100644 index 00000000..8009606d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoBeforeSerializationAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ecc2edf1ed394eb459ad04d80963ff0c +timeCreated: 1611404789 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs new file mode 100644 index 00000000..ee0e6152 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs @@ -0,0 +1,194 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface, AllowMultiple = false, Inherited = false)] + public sealed class ProtoContractAttribute : Attribute + { + public string Name + { + get + { + return this.name; + } + set + { + this.name = value; + } + } + + public int ImplicitFirstTag + { + get + { + return this.implicitFirstTag; + } + set + { + bool flag = value < 1; + if (flag) + { + throw new ArgumentOutOfRangeException("ImplicitFirstTag"); + } + this.implicitFirstTag = value; + } + } + + public bool UseProtoMembersOnly + { + get + { + return this.HasFlag(4); + } + set + { + this.SetFlag(4, value); + } + } + + public bool IgnoreListHandling + { + get + { + return this.HasFlag(16); + } + set + { + this.SetFlag(16, value); + } + } + + public ImplicitFields ImplicitFields + { + get + { + return this.implicitFields; + } + set + { + this.implicitFields = value; + } + } + + public bool InferTagFromName + { + get + { + return this.HasFlag(1); + } + set + { + this.SetFlag(1, value); + this.SetFlag(2, true); + } + } + + internal bool InferTagFromNameHasValue + { + get + { + return this.HasFlag(2); + } + } + + public int DataMemberOffset + { + get + { + return this.dataMemberOffset; + } + set + { + this.dataMemberOffset = value; + } + } + + public bool SkipConstructor + { + get + { + return this.HasFlag(8); + } + set + { + this.SetFlag(8, value); + } + } + + public bool AsReferenceDefault + { + get + { + return this.HasFlag(32); + } + set + { + this.SetFlag(32, value); + } + } + + public bool EnumPassthru + { + get + { + return this.HasFlag(64); + } + set + { + this.SetFlag(64, value); + this.SetFlag(128, true); + } + } + + internal bool EnumPassthruHasValue + { + get + { + return this.HasFlag(128); + } + } + + private string name; + + private int implicitFirstTag; + + private ImplicitFields implicitFields; + + private int dataMemberOffset; + + private byte flags; + + private const byte OPTIONS_InferTagFromName = 1; + + private const byte OPTIONS_InferTagFromNameHasValue = 2; + + private const byte OPTIONS_UseProtoMembersOnly = 4; + + private const byte OPTIONS_SkipConstructor = 8; + + private const byte OPTIONS_IgnoreListHandling = 16; + + private const byte OPTIONS_AsReferenceDefault = 32; + + private const byte OPTIONS_EnumPassthru = 64; + + private const byte OPTIONS_EnumPassthruHasValue = 128; + + private bool HasFlag(byte flag) + { + return (this.flags & flag) == flag; + } + + private void SetFlag(byte flag, bool value) + { + if (value) + { + this.flags |= flag; + } + else + { + this.flags &= (byte)~flag; + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs.meta new file mode 100644 index 00000000..bdd12f5c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoContractAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 757e2bbf79dd9494181d2d7761cb30be +timeCreated: 1611403947 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs new file mode 100644 index 00000000..2aea27a3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] + public class ProtoConverterAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs.meta new file mode 100644 index 00000000..f57b8fc4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoConverterAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 63944827ef6f6e74b917e6c102af5910 +timeCreated: 1611403845 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs new file mode 100644 index 00000000..926a33c7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs @@ -0,0 +1,44 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)] + public sealed class ProtoEnumAttribute : Attribute + { + public int Value + { + get + { + return this.enumValue; + } + set + { + this.enumValue = value; + this.hasValue = true; + } + } + + public string Name + { + get + { + return this.name; + } + set + { + this.name = value; + } + } + + private bool hasValue; + + private int enumValue; + + private string name; + + public bool HasValue() + { + return this.hasValue; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs.meta new file mode 100644 index 00000000..b087db5b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoEnumAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 2bb65995e007f6742878be5afc628d7b +timeCreated: 1611403500 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs new file mode 100644 index 00000000..975e48e4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs @@ -0,0 +1,19 @@ +using System; + +namespace ProtoBuf +{ + public class ProtoException : Exception + { + public ProtoException() + { + } + + public ProtoException(string message) : base(message) + { + } + + public ProtoException(string message, Exception innerException) : base(message, innerException) + { + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs.meta new file mode 100644 index 00000000..4c5e796b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoException.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: a17e3b9814e9d2a4681a8464052a82b8 +timeCreated: 1611404253 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs new file mode 100644 index 00000000..bc3f0c50 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs @@ -0,0 +1,9 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)] + public class ProtoIgnoreAttribute : Attribute + { + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs.meta new file mode 100644 index 00000000..a68a8299 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIgnoreAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 2db07068e8e9a9d48948e00e0b551fe9 +timeCreated: 1611403507 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs new file mode 100644 index 00000000..020fb23c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs @@ -0,0 +1,73 @@ +using System; +using System.ComponentModel; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)] + public sealed class ProtoIncludeAttribute : Attribute + { + public int Tag + { + get + { + return this.tag; + } + } + + public string KnownTypeName + { + get + { + return this.knownTypeName; + } + } + + public Type KnownType + { + get + { + return TypeModel.ResolveKnownType(this.KnownTypeName, null, null); + } + } + + [DefaultValue(DataFormat.Default)] + public DataFormat DataFormat + { + get + { + return this.dataFormat; + } + set + { + this.dataFormat = value; + } + } + + private readonly int tag; + + private readonly string knownTypeName; + + private DataFormat dataFormat = DataFormat.Default; + + public ProtoIncludeAttribute(int tag, Type knownType) : this(tag, (knownType == null) ? "" : knownType.AssemblyQualifiedName) + { + } + + public ProtoIncludeAttribute(int tag, string knownTypeName) + { + bool flag = tag <= 0; + if (flag) + { + throw new ArgumentOutOfRangeException("tag", "Tags must be positive integers"); + } + bool flag2 = Helpers.IsNullOrEmpty(knownTypeName); + if (flag2) + { + throw new ArgumentNullException("knownTypeName", "Known type cannot be blank"); + } + this.tag = tag; + this.knownTypeName = knownTypeName; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs.meta new file mode 100644 index 00000000..1ea6b8c6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoIncludeAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f49c8ded347e5aa4d9490ab48c4ad8f8 +timeCreated: 1611404855 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs new file mode 100644 index 00000000..608b696e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs @@ -0,0 +1,233 @@ +using System; +using System.Reflection; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)] + public class ProtoMemberAttribute : Attribute, IComparable, IComparable + { + public string Name + { + get + { + return this.name; + } + set + { + this.name = value; + } + } + + public DataFormat DataFormat + { + get + { + return this.dataFormat; + } + set + { + this.dataFormat = value; + } + } + + public int Tag + { + get + { + return this.tag; + } + } + + public bool IsRequired + { + get + { + return (this.options & MemberSerializationOptions.Required) == MemberSerializationOptions.Required; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.Required; + } + else + { + this.options &= ~MemberSerializationOptions.Required; + } + } + } + + public bool IsPacked + { + get + { + return (this.options & MemberSerializationOptions.Packed) == MemberSerializationOptions.Packed; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.Packed; + } + else + { + this.options &= ~MemberSerializationOptions.Packed; + } + } + } + + public bool OverwriteList + { + get + { + return (this.options & MemberSerializationOptions.OverwriteList) == MemberSerializationOptions.OverwriteList; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.OverwriteList; + } + else + { + this.options &= ~MemberSerializationOptions.OverwriteList; + } + } + } + + public bool AsReference + { + get + { + return (this.options & MemberSerializationOptions.AsReference) == MemberSerializationOptions.AsReference; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.AsReference; + } + else + { + this.options &= ~MemberSerializationOptions.AsReference; + } + this.options |= MemberSerializationOptions.AsReferenceHasValue; + } + } + + internal bool AsReferenceHasValue + { + get + { + return (this.options & MemberSerializationOptions.AsReferenceHasValue) == MemberSerializationOptions.AsReferenceHasValue; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.AsReferenceHasValue; + } + else + { + this.options &= ~MemberSerializationOptions.AsReferenceHasValue; + } + } + } + + public bool DynamicType + { + get + { + return (this.options & MemberSerializationOptions.DynamicType) == MemberSerializationOptions.DynamicType; + } + set + { + if (value) + { + this.options |= MemberSerializationOptions.DynamicType; + } + else + { + this.options &= ~MemberSerializationOptions.DynamicType; + } + } + } + + public MemberSerializationOptions Options + { + get + { + return this.options; + } + set + { + this.options = value; + } + } + + internal MemberInfo Member; + + internal bool TagIsPinned; + + private string name; + + private DataFormat dataFormat; + + private int tag; + + private MemberSerializationOptions options; + + public int CompareTo(object other) + { + return this.CompareTo(other as ProtoMemberAttribute); + } + + public int CompareTo(ProtoMemberAttribute other) + { + bool flag = other == null; + int result; + if (flag) + { + result = -1; + } + else + { + bool flag2 = this == other; + if (flag2) + { + result = 0; + } + else + { + int num = this.tag.CompareTo(other.tag); + bool flag3 = num == 0; + if (flag3) + { + num = string.CompareOrdinal(this.name, other.name); + } + result = num; + } + } + return result; + } + + public ProtoMemberAttribute(int tag) : this(tag, false) + { + } + + internal ProtoMemberAttribute(int tag, bool forced) + { + bool flag = tag <= 0 && !forced; + if (flag) + { + throw new ArgumentOutOfRangeException("tag"); + } + this.tag = tag; + } + + internal void Rebase(int tag) + { + this.tag = tag; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs.meta new file mode 100644 index 00000000..11aa41da --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoMemberAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4ce9640748d13be458e0f9ec67e676c9 +timeCreated: 1611403693 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs new file mode 100644 index 00000000..86939880 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs @@ -0,0 +1,28 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)] + public sealed class ProtoPartialIgnoreAttribute : ProtoIgnoreAttribute + { + public string MemberName + { + get + { + return this.memberName; + } + } + + private readonly string memberName; + + public ProtoPartialIgnoreAttribute(string memberName) + { + bool flag = Helpers.IsNullOrEmpty(memberName); + if (flag) + { + throw new ArgumentNullException("memberName"); + } + this.memberName = memberName; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs.meta new file mode 100644 index 00000000..e0c35110 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialIgnoreAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 038d279d0054d4a4c944c48a509e1a43 +timeCreated: 1611402959 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs new file mode 100644 index 00000000..5c352c16 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs @@ -0,0 +1,28 @@ +using System; + +namespace ProtoBuf +{ + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)] + public sealed class ProtoPartialMemberAttribute : ProtoMemberAttribute + { + public string MemberName + { + get + { + return this.memberName; + } + } + + private readonly string memberName; + + public ProtoPartialMemberAttribute(int tag, string memberName) : base(tag) + { + bool flag = Helpers.IsNullOrEmpty(memberName); + if (flag) + { + throw new ArgumentNullException("memberName"); + } + this.memberName = memberName; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs.meta new file mode 100644 index 00000000..418e5806 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoPartialMemberAttribute.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4e83197626245624caf62b9555d960e9 +timeCreated: 1611403698 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs new file mode 100644 index 00000000..74daf36f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs @@ -0,0 +1,1838 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + public sealed class ProtoReader : IDisposable + { + public int FieldNumber + { + get + { + return this.fieldNumber; + } + } + + public WireType WireType + { + get + { + return this.wireType; + } + } + + public bool InternStrings + { + get + { + return this.internStrings; + } + set + { + this.internStrings = value; + } + } + + public SerializationContext Context + { + get + { + return this.context; + } + } + + public int Position + { + get + { + return this.position; + } + } + + public TypeModel Model + { + get + { + return this.model; + } + } + + internal NetObjectCache NetCache + { + get + { + return this.netCache; + } + } + + private Stream source; + + private byte[] ioBuffer; + + private TypeModel model; + + private int fieldNumber; + + private int depth; + + private int dataRemaining; + + private int ioIndex; + + private int position; + + private int available; + + private int blockEnd; + + private WireType wireType; + + private bool isFixedLength; + + private bool internStrings; + + private NetObjectCache netCache; + + private uint trapCount; + + internal const int TO_EOF = -1; + + private SerializationContext context; + + private const long Int64Msb = -9223372036854775808L; + + private const int Int32Msb = -2147483648; + + private Dictionary stringInterner; + + private static readonly UTF8Encoding encoding = new UTF8Encoding(); + + private static readonly byte[] EmptyBlob = new byte[0]; + + [ThreadStatic] + private static ProtoReader lastReader; + + public ProtoReader(Stream source, TypeModel model, SerializationContext context) + { + ProtoReader.Init(this, source, model, context, -1); + } + + public ProtoReader(Stream source, TypeModel model, SerializationContext context, int length) + { + ProtoReader.Init(this, source, model, context, length); + } + + private static void Init(ProtoReader reader, Stream source, TypeModel model, SerializationContext context, int length) + { + bool flag = source == null; + if (flag) + { + throw new ArgumentNullException("source"); + } + bool flag2 = !source.CanRead; + if (flag2) + { + throw new ArgumentException("Cannot read from stream", "source"); + } + reader.source = source; + reader.ioBuffer = BufferPool.GetBuffer(); + reader.model = model; + bool flag3 = length >= 0; + reader.isFixedLength = flag3; + reader.dataRemaining = (flag3 ? length : 0); + bool flag4 = context == null; + if (flag4) + { + context = SerializationContext.Default; + } + else + { + context.Freeze(); + } + reader.context = context; + reader.position = (reader.available = (reader.depth = (reader.fieldNumber = (reader.ioIndex = 0)))); + reader.blockEnd = int.MaxValue; + reader.internStrings = true; + reader.wireType = WireType.None; + reader.trapCount = 1u; + bool flag5 = reader.netCache == null; + if (flag5) + { + reader.netCache = new NetObjectCache(); + } + } + + public void Dispose() + { + this.source = null; + this.model = null; + BufferPool.ReleaseBufferToPool(ref this.ioBuffer); + bool flag = this.stringInterner != null; + if (flag) + { + this.stringInterner.Clear(); + } + bool flag2 = this.netCache != null; + if (flag2) + { + this.netCache.Clear(); + } + } + + internal int TryReadUInt32VariantWithoutMoving(bool trimNegative, out uint value) + { + bool flag = this.available < 10; + if (flag) + { + this.Ensure(10, false); + } + bool flag2 = this.available == 0; + int result; + if (flag2) + { + value = 0u; + result = 0; + } + else + { + int num = this.ioIndex; + value = (uint)this.ioBuffer[num++]; + bool flag3 = (value & 128u) == 0u; + if (flag3) + { + result = 1; + } + else + { + value &= 127u; + bool flag4 = this.available == 1; + if (flag4) + { + throw ProtoReader.EoF(this); + } + uint num2 = (uint)this.ioBuffer[num++]; + value |= (num2 & 127u) << 7; + bool flag5 = (num2 & 128u) == 0u; + if (flag5) + { + result = 2; + } + else + { + bool flag6 = this.available == 2; + if (flag6) + { + throw ProtoReader.EoF(this); + } + num2 = (uint)this.ioBuffer[num++]; + value |= (num2 & 127u) << 14; + bool flag7 = (num2 & 128u) == 0u; + if (flag7) + { + result = 3; + } + else + { + bool flag8 = this.available == 3; + if (flag8) + { + throw ProtoReader.EoF(this); + } + num2 = (uint)this.ioBuffer[num++]; + value |= (num2 & 127u) << 21; + bool flag9 = (num2 & 128u) == 0u; + if (flag9) + { + result = 4; + } + else + { + bool flag10 = this.available == 4; + if (flag10) + { + throw ProtoReader.EoF(this); + } + num2 = (uint)this.ioBuffer[num]; + value |= num2 << 28; + bool flag11 = (num2 & 240u) == 0u; + if (flag11) + { + result = 5; + } + else + { + bool flag12 = trimNegative && (num2 & 240u) == 240u && this.available >= 10 && this.ioBuffer[++num] == byte.MaxValue && this.ioBuffer[++num] == byte.MaxValue && this.ioBuffer[++num] == byte.MaxValue && this.ioBuffer[++num] == byte.MaxValue && this.ioBuffer[num + 1] == 1; + if (!flag12) + { + throw ProtoReader.AddErrorData(new OverflowException(), this); + } + result = 10; + } + } + } + } + } + } + return result; + } + + private uint ReadUInt32Variant(bool trimNegative) + { + uint result; + int num = this.TryReadUInt32VariantWithoutMoving(trimNegative, out result); + bool flag = num > 0; + if (flag) + { + this.ioIndex += num; + this.available -= num; + this.position += num; + return result; + } + throw ProtoReader.EoF(this); + } + + private bool TryReadUInt32Variant(out uint value) + { + int num = this.TryReadUInt32VariantWithoutMoving(false, out value); + bool flag = num > 0; + bool result; + if (flag) + { + this.ioIndex += num; + this.available -= num; + this.position += num; + result = true; + } + else + { + result = false; + } + return result; + } + + public uint ReadUInt32() + { + WireType wireType = this.wireType; + uint result; + if (wireType != WireType.Variant) + { + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw this.CreateWireTypeException(); + } + bool flag = this.available < 4; + if (flag) + { + this.Ensure(4, true); + } + this.position += 4; + this.available -= 4; + byte[] array = this.ioBuffer; + int num = this.ioIndex; + this.ioIndex = num + 1; + uint num2 = array[num]; + byte[] array2 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + uint num3 = (uint)(num2 | array2[num] << 8); + byte[] array3 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + uint num4 = (uint)(num3 | array3[num] << 16); + byte[] array4 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + result = (uint)(num4 | array4[num] << 24); + } + else + { + ulong num5 = this.ReadUInt64(); + result = checked((uint)num5); + } + } + else + { + result = this.ReadUInt32Variant(false); + } + return result; + } + + internal void Ensure(int count, bool strict) + { + Helpers.DebugAssert(this.available <= count, "Asking for data without checking first"); + bool flag = count > this.ioBuffer.Length; + if (flag) + { + BufferPool.ResizeAndFlushLeft(ref this.ioBuffer, count, this.ioIndex, this.available); + this.ioIndex = 0; + } + else + { + bool flag2 = this.ioIndex + count >= this.ioBuffer.Length; + if (flag2) + { + Helpers.BlockCopy(this.ioBuffer, this.ioIndex, this.ioBuffer, 0, this.available); + this.ioIndex = 0; + } + } + count -= this.available; + int num = this.ioIndex + this.available; + int num2 = this.ioBuffer.Length - num; + bool flag3 = this.isFixedLength; + if (flag3) + { + bool flag4 = this.dataRemaining < num2; + if (flag4) + { + num2 = this.dataRemaining; + } + } + int num3; + while (count > 0 && num2 > 0 && (num3 = this.source.Read(this.ioBuffer, num, num2)) > 0) + { + this.available += num3; + count -= num3; + num2 -= num3; + num += num3; + bool flag5 = this.isFixedLength; + if (flag5) + { + this.dataRemaining -= num3; + } + } + bool flag6 = strict && count > 0; + if (flag6) + { + throw ProtoReader.EoF(this); + } + } + + public short ReadInt16() + { + return checked((short)this.ReadInt32()); + } + + public ushort ReadUInt16() + { + return checked((ushort)this.ReadUInt32()); + } + + public byte ReadByte() + { + return checked((byte)this.ReadUInt32()); + } + + public sbyte ReadSByte() + { + return checked((sbyte)this.ReadInt32()); + } + + public int ReadInt32() + { + WireType wireType = this.wireType; + if (wireType <= WireType.Fixed64) + { + if (wireType == WireType.Variant) + { + return (int)this.ReadUInt32Variant(true); + } + if (wireType == WireType.Fixed64) + { + long num = this.ReadInt64(); + return checked((int)num); + } + } + else + { + if (wireType == WireType.Fixed32) + { + bool flag = this.available < 4; + if (flag) + { + this.Ensure(4, true); + } + this.position += 4; + this.available -= 4; + byte[] array = this.ioBuffer; + int num2 = this.ioIndex; + this.ioIndex = num2 + 1; + int num3 = array[num2]; + byte[] array2 = this.ioBuffer; + num2 = this.ioIndex; + this.ioIndex = num2 + 1; + int num4 = num3 | array2[num2] << 8; + byte[] array3 = this.ioBuffer; + num2 = this.ioIndex; + this.ioIndex = num2 + 1; + int num5 = num4 | array3[num2] << 16; + byte[] array4 = this.ioBuffer; + num2 = this.ioIndex; + this.ioIndex = num2 + 1; + return num5 | array4[num2] << 24; + } + if (wireType == WireType.SignedVariant) + { + return ProtoReader.Zag(this.ReadUInt32Variant(true)); + } + } + throw this.CreateWireTypeException(); + } + + private static int Zag(uint ziggedValue) + { + return (int)(-(ziggedValue & 1u) ^ (uint)((int)ziggedValue >> 1 & int.MaxValue)); + } + + private static long Zag(ulong ziggedValue) + { + //! + //return (long)(-(long)(ziggedValue & 1UL) ^ (ziggedValue >> 1 & 9223372036854775807UL)); + long rightPart = (long)( ziggedValue >> 1 & long.MaxValue ); + long leftPart = -(long)(ziggedValue & 1UL); + return leftPart ^ rightPart; + } + + public long ReadInt64() + { + WireType wireType = this.wireType; + if (wireType <= WireType.Fixed64) + { + if (wireType == WireType.Variant) + { + return (long)this.ReadUInt64Variant(); + } + if (wireType == WireType.Fixed64) + { + bool flag = this.available < 8; + if (flag) + { + this.Ensure(8, true); + } + this.position += 8; + this.available -= 8; + byte[] array = this.ioBuffer; + int num = this.ioIndex; + this.ioIndex = num + 1; + long num2 = (long)array[num]; + byte[] array2 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num3 = num2 | (long)((long)array2[num] << 8); + byte[] array3 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num4 = num3 | (long)((long)array3[num] << 16); + byte[] array4 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num5 = num4 | (long)((long)array4[num] << 24); + byte[] array5 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num6 = num5 | (long)((long)array5[num] << 32); + byte[] array6 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num7 = num6 | (long)((long)array6[num] << 40); + byte[] array7 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + long num8 = num7 | (long)((long)array7[num] << 48); + byte[] array8 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + return num8 | (long)((long)array8[num] << 56); + } + } + else + { + if (wireType == WireType.Fixed32) + { + return (long)this.ReadInt32(); + } + if (wireType == WireType.SignedVariant) + { + return ProtoReader.Zag(this.ReadUInt64Variant()); + } + } + throw this.CreateWireTypeException(); + } + + private int TryReadUInt64VariantWithoutMoving(out ulong value) + { + bool flag = this.available < 10; + if (flag) + { + this.Ensure(10, false); + } + bool flag2 = this.available == 0; + int result; + if (flag2) + { + value = 0UL; + result = 0; + } + else + { + int num = this.ioIndex; + value = (ulong)this.ioBuffer[num++]; + bool flag3 = (value & 128UL) == 0UL; + if (flag3) + { + result = 1; + } + else + { + value &= 127UL; + bool flag4 = this.available == 1; + if (flag4) + { + throw ProtoReader.EoF(this); + } + ulong num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 7; + bool flag5 = (num2 & 128UL) == 0UL; + if (flag5) + { + result = 2; + } + else + { + bool flag6 = this.available == 2; + if (flag6) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 14; + bool flag7 = (num2 & 128UL) == 0UL; + if (flag7) + { + result = 3; + } + else + { + bool flag8 = this.available == 3; + if (flag8) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 21; + bool flag9 = (num2 & 128UL) == 0UL; + if (flag9) + { + result = 4; + } + else + { + bool flag10 = this.available == 4; + if (flag10) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 28; + bool flag11 = (num2 & 128UL) == 0UL; + if (flag11) + { + result = 5; + } + else + { + bool flag12 = this.available == 5; + if (flag12) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 35; + bool flag13 = (num2 & 128UL) == 0UL; + if (flag13) + { + result = 6; + } + else + { + bool flag14 = this.available == 6; + if (flag14) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 42; + bool flag15 = (num2 & 128UL) == 0UL; + if (flag15) + { + result = 7; + } + else + { + bool flag16 = this.available == 7; + if (flag16) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 49; + bool flag17 = (num2 & 128UL) == 0UL; + if (flag17) + { + result = 8; + } + else + { + bool flag18 = this.available == 8; + if (flag18) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num++]; + value |= (num2 & 127UL) << 56; + bool flag19 = (num2 & 128UL) == 0UL; + if (flag19) + { + result = 9; + } + else + { + bool flag20 = this.available == 9; + if (flag20) + { + throw ProtoReader.EoF(this); + } + num2 = (ulong)this.ioBuffer[num]; + value |= num2 << 63; + bool flag21 = (num2 & 18446744073709551614UL) > 0UL; + if (flag21) + { + throw ProtoReader.AddErrorData(new OverflowException(), this); + } + result = 10; + } + } + } + } + } + } + } + } + } + } + return result; + } + + private ulong ReadUInt64Variant() + { + ulong result; + int num = this.TryReadUInt64VariantWithoutMoving(out result); + bool flag = num > 0; + if (flag) + { + this.ioIndex += num; + this.available -= num; + this.position += num; + return result; + } + throw ProtoReader.EoF(this); + } + + private string Intern(string value) + { + bool flag = value == null; + string result; + if (flag) + { + result = null; + } + else + { + bool flag2 = value.Length == 0; + if (flag2) + { + result = ""; + } + else + { + bool flag3 = this.stringInterner == null; + if (flag3) + { + this.stringInterner = new Dictionary(); + this.stringInterner.Add(value, value); + } + else + { + string text; + bool flag4 = this.stringInterner.TryGetValue(value, out text); + if (flag4) + { + value = text; + } + else + { + this.stringInterner.Add(value, value); + } + } + result = value; + } + } + return result; + } + + public string ReadString() + { + bool flag = this.wireType == WireType.String; + if (flag) + { + int num = (int)this.ReadUInt32Variant(false); + bool flag2 = num == 0; + string result; + if (flag2) + { + result = ""; + } + else + { + bool flag3 = this.available < num; + if (flag3) + { + this.Ensure(num, true); + } + string text = ProtoReader.encoding.GetString(this.ioBuffer, this.ioIndex, num); + bool flag4 = this.internStrings; + if (flag4) + { + text = this.Intern(text); + } + this.available -= num; + this.position += num; + this.ioIndex += num; + result = text; + } + return result; + } + throw this.CreateWireTypeException(); + } + + public void ThrowEnumException(Type type, int value) + { + string str = (type == null) ? "" : type.FullName; + throw ProtoReader.AddErrorData(new ProtoException("No " + str + " enum is mapped to the wire-value " + value.ToString()), this); + } + + private Exception CreateWireTypeException() + { + return this.CreateException("Invalid wire-type; this usually means you have over-written a file without truncating or setting the length; see http://stackoverflow.com/q/2152978/23354"); + } + + private Exception CreateException(string message) + { + return ProtoReader.AddErrorData(new ProtoException(message), this); + } + + public unsafe double ReadDouble() + { + WireType wireType = this.wireType; + double result; + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw this.CreateWireTypeException(); + } + result = (double)this.ReadSingle(); + } + else + { + long num = this.ReadInt64(); + result = *(double*)(&num); + } + return result; + } + + public static object ReadObject(object value, int key, ProtoReader reader) + { + return ProtoReader.ReadTypedObject(value, key, reader, null); + } + + internal static object ReadTypedObject(object value, int key, ProtoReader reader, Type type) + { + bool flag = reader.model == null; + if (flag) + { + throw ProtoReader.AddErrorData(new InvalidOperationException("Cannot deserialize sub-objects unless a model is provided"), reader); + } + SubItemToken token = ProtoReader.StartSubItem(reader); + bool flag2 = key >= 0; + if (flag2) + { + value = reader.model.Deserialize(key, value, reader); + } + else + { + bool flag3 = type != null && reader.model.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false); + if (!flag3) + { + TypeModel.ThrowUnexpectedType(type); + } + } + ProtoReader.EndSubItem(token, reader); + return value; + } + + public static void EndSubItem(SubItemToken token, ProtoReader reader) + { + bool flag = reader == null; + if (flag) + { + throw new ArgumentNullException("reader"); + } + int value = token.value; + WireType wireType = reader.wireType; + if (wireType != WireType.EndGroup) + { + bool flag2 = value < reader.position; + if (flag2) + { + throw reader.CreateException("Sub-message not read entirely"); + } + bool flag3 = reader.blockEnd != reader.position && reader.blockEnd != int.MaxValue; + if (flag3) + { + throw reader.CreateException("Sub-message not read correctly"); + } + reader.blockEnd = value; + reader.depth--; + } + else + { + bool flag4 = value >= 0; + if (flag4) + { + throw ProtoReader.AddErrorData(new ArgumentException("token"), reader); + } + bool flag5 = -value != reader.fieldNumber; + if (flag5) + { + throw reader.CreateException("Wrong group was ended"); + } + reader.wireType = WireType.None; + reader.depth--; + } + } + + public static SubItemToken StartSubItem(ProtoReader reader) + { + bool flag = reader == null; + if (flag) + { + throw new ArgumentNullException("reader"); + } + WireType wireType = reader.wireType; + SubItemToken result; + if (wireType != WireType.String) + { + if (wireType != WireType.StartGroup) + { + throw reader.CreateWireTypeException(); + } + reader.wireType = WireType.None; + reader.depth++; + result = new SubItemToken(-reader.fieldNumber); + } + else + { + int num = (int)reader.ReadUInt32Variant(false); + bool flag2 = num < 0; + if (flag2) + { + throw ProtoReader.AddErrorData(new InvalidOperationException(), reader); + } + int value = reader.blockEnd; + reader.blockEnd = reader.position + num; + reader.depth++; + result = new SubItemToken(value); + } + return result; + } + + public int ReadFieldHeader() + { + bool flag = this.blockEnd <= this.position || this.wireType == WireType.EndGroup; + int result; + if (flag) + { + result = 0; + } + else + { + uint num; + bool flag2 = this.TryReadUInt32Variant(out num); + if (flag2) + { + this.wireType = (WireType)(num & 7u); + this.fieldNumber = (int)(num >> 3); + bool flag3 = this.fieldNumber < 1; + if (flag3) + { + throw new ProtoException("Invalid field in source data: " + this.fieldNumber.ToString()); + } + } + else + { + this.wireType = WireType.None; + this.fieldNumber = 0; + } + bool flag4 = this.wireType == WireType.EndGroup; + if (flag4) + { + bool flag5 = this.depth > 0; + if (!flag5) + { + throw new ProtoException("Unexpected end-group in source data; this usually means the source data is corrupt"); + } + result = 0; + } + else + { + result = this.fieldNumber; + } + } + return result; + } + + public bool TryReadFieldHeader(int field) + { + bool flag = this.blockEnd <= this.position || this.wireType == WireType.EndGroup; + bool result; + if (flag) + { + result = false; + } + else + { + uint num2; + int num = this.TryReadUInt32VariantWithoutMoving(false, out num2); + WireType wireType = WireType.None; + bool flag2 = num > 0 && (int)num2 >> 3 == field && (wireType = (WireType)(num2 & 7u)) != WireType.EndGroup; + if (flag2) + { + this.wireType = wireType; + this.fieldNumber = field; + this.position += num; + this.ioIndex += num; + this.available -= num; + result = true; + } + else + { + result = false; + } + } + return result; + } + + public void Hint(WireType wireType) + { + bool flag = this.wireType == wireType; + if (!flag) + { + bool flag2 = (wireType & (WireType)7) == this.wireType; + if (flag2) + { + this.wireType = wireType; + } + } + } + + public void Assert(WireType wireType) + { + bool flag = this.wireType == wireType; + if (!flag) + { + bool flag2 = (wireType & (WireType)7) == this.wireType; + if (!flag2) + { + throw this.CreateWireTypeException(); + } + this.wireType = wireType; + } + } + + public void SkipField() + { + switch (this.wireType) + { + case WireType.Variant: + case WireType.SignedVariant: + this.ReadUInt64Variant(); + return; + case WireType.Fixed64: + { + bool flag = this.available < 8; + if (flag) + { + this.Ensure(8, true); + } + this.available -= 8; + this.ioIndex += 8; + this.position += 8; + return; + } + case WireType.String: + { + int num = (int)this.ReadUInt32Variant(false); + bool flag2 = num <= this.available; + if (flag2) + { + this.available -= num; + this.ioIndex += num; + this.position += num; + return; + } + this.position += num; + num -= this.available; + this.ioIndex = (this.available = 0); + bool flag3 = this.isFixedLength; + if (flag3) + { + bool flag4 = num > this.dataRemaining; + if (flag4) + { + throw ProtoReader.EoF(this); + } + this.dataRemaining -= num; + } + ProtoReader.Seek(this.source, num, this.ioBuffer); + return; + } + case WireType.StartGroup: + { + int num2 = this.fieldNumber; + this.depth++; + while (this.ReadFieldHeader() > 0) + { + this.SkipField(); + } + this.depth--; + bool flag5 = this.wireType == WireType.EndGroup && this.fieldNumber == num2; + if (flag5) + { + this.wireType = WireType.None; + return; + } + throw this.CreateWireTypeException(); + } + case WireType.Fixed32: + { + bool flag6 = this.available < 4; + if (flag6) + { + this.Ensure(4, true); + } + this.available -= 4; + this.ioIndex += 4; + this.position += 4; + return; + } + } + throw this.CreateWireTypeException(); + } + + public ulong ReadUInt64() + { + WireType wireType = this.wireType; + ulong result; + if (wireType != WireType.Variant) + { + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw this.CreateWireTypeException(); + } + result = (ulong)this.ReadUInt32(); + } + else + { + bool flag = this.available < 8; + if (flag) + { + this.Ensure(8, true); + } + this.position += 8; + this.available -= 8; + byte[] array = this.ioBuffer; + int num = this.ioIndex; + this.ioIndex = num + 1; + ulong num2 = array[num]; + byte[] array2 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num3 = num2 | (ulong) ( array2[num] << 8); + byte[] array3 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num4 = num3 | (ulong) (array3[num] << 16); + byte[] array4 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num5 = num4 | (ulong) ( array4[num] << 24); + byte[] array5 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num6 = num5 | (ulong)(array5[num] << 32); + byte[] array6 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num7 = num6 | (ulong)( array6[num] << 40); + byte[] array7 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + ulong num8 = num7 | (ulong)(array7[num] << 48); + byte[] array8 = this.ioBuffer; + num = this.ioIndex; + this.ioIndex = num + 1; + result = (num8 | (ulong) ( array8[num] << 56)); + } + } + else + { + result = this.ReadUInt64Variant(); + } + return result; + } + + public unsafe float ReadSingle() + { + WireType wireType = this.wireType; + float result; + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw this.CreateWireTypeException(); + } + int num = this.ReadInt32(); + result = *(float*)(&num); + } + else + { + double num2 = this.ReadDouble(); + float num3 = (float)num2; + bool flag = Helpers.IsInfinity(num3) && !Helpers.IsInfinity(num2); + if (flag) + { + throw ProtoReader.AddErrorData(new OverflowException(), this); + } + result = num3; + } + return result; + } + + public bool ReadBoolean() + { + uint num = this.ReadUInt32(); + bool result; + if (num != 0u) + { + if (num != 1u) + { + throw this.CreateException("Unexpected boolean value"); + } + result = true; + } + else + { + result = false; + } + return result; + } + + public static byte[] AppendBytes(byte[] value, ProtoReader reader) + { + bool flag = reader == null; + if (flag) + { + throw new ArgumentNullException("reader"); + } + WireType wireType = reader.wireType; + if (wireType != WireType.String) + { + throw reader.CreateWireTypeException(); + } + int i = (int)reader.ReadUInt32Variant(false); + reader.wireType = WireType.None; + bool flag2 = i == 0; + byte[] result; + if (flag2) + { + result = ((value == null) ? ProtoReader.EmptyBlob : value); + } + else + { + bool flag3 = value == null || value.Length == 0; + int num; + if (flag3) + { + num = 0; + value = new byte[i]; + } + else + { + num = value.Length; + byte[] array = new byte[value.Length + i]; + Helpers.BlockCopy(value, 0, array, 0, value.Length); + value = array; + } + reader.position += i; + while (i > reader.available) + { + bool flag4 = reader.available > 0; + if (flag4) + { + Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num, reader.available); + i -= reader.available; + num += reader.available; + reader.ioIndex = (reader.available = 0); + } + int num2 = (i > reader.ioBuffer.Length) ? reader.ioBuffer.Length : i; + bool flag5 = num2 > 0; + if (flag5) + { + reader.Ensure(num2, true); + } + } + bool flag6 = i > 0; + if (flag6) + { + Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num, i); + reader.ioIndex += i; + reader.available -= i; + } + result = value; + } + return result; + } + + private static int ReadByteOrThrow(Stream source) + { + int num = source.ReadByte(); + bool flag = num < 0; + if (flag) + { + throw ProtoReader.EoF(null); + } + return num; + } + + public static int ReadLengthPrefix(Stream source, bool expectHeader, PrefixStyle style, out int fieldNumber) + { + int num; + return ProtoReader.ReadLengthPrefix(source, expectHeader, style, out fieldNumber, out num); + } + + public static int DirectReadLittleEndianInt32(Stream source) + { + return ProtoReader.ReadByteOrThrow(source) | ProtoReader.ReadByteOrThrow(source) << 8 | ProtoReader.ReadByteOrThrow(source) << 16 | ProtoReader.ReadByteOrThrow(source) << 24; + } + + public static int DirectReadBigEndianInt32(Stream source) + { + return ProtoReader.ReadByteOrThrow(source) << 24 | ProtoReader.ReadByteOrThrow(source) << 16 | ProtoReader.ReadByteOrThrow(source) << 8 | ProtoReader.ReadByteOrThrow(source); + } + + public static int DirectReadVarintInt32(Stream source) + { + uint result; + int num = ProtoReader.TryReadUInt32Variant(source, out result); + bool flag = num <= 0; + if (flag) + { + throw ProtoReader.EoF(null); + } + return (int)result; + } + + public static void DirectReadBytes(Stream source, byte[] buffer, int offset, int count) + { + bool flag = source == null; + if (flag) + { + throw new ArgumentNullException("source"); + } + int num; + while (count > 0 && (num = source.Read(buffer, offset, count)) > 0) + { + count -= num; + offset += num; + } + bool flag2 = count > 0; + if (flag2) + { + throw ProtoReader.EoF(null); + } + } + + public static byte[] DirectReadBytes(Stream source, int count) + { + byte[] array = new byte[count]; + ProtoReader.DirectReadBytes(source, array, 0, count); + return array; + } + + public static string DirectReadString(Stream source, int length) + { + byte[] array = new byte[length]; + ProtoReader.DirectReadBytes(source, array, 0, length); + return Encoding.UTF8.GetString(array, 0, length); + } + + public static int ReadLengthPrefix(Stream source, bool expectHeader, PrefixStyle style, out int fieldNumber, out int bytesRead) + { + fieldNumber = 0; + int result; + switch (style) + { + case PrefixStyle.None: + bytesRead = 0; + result = int.MaxValue; + break; + case PrefixStyle.Base128: + bytesRead = 0; + if (expectHeader) + { + uint num2; + int num = ProtoReader.TryReadUInt32Variant(source, out num2); + bytesRead += num; + bool flag = num > 0; + if (flag) + { + bool flag2 = (num2 & 7u) != 2u; + if (flag2) + { + throw new InvalidOperationException(); + } + fieldNumber = (int)(num2 >> 3); + num = ProtoReader.TryReadUInt32Variant(source, out num2); + bytesRead += num; + bool flag3 = bytesRead == 0; + if (flag3) + { + throw ProtoReader.EoF(null); + } + result = (int)num2; + } + else + { + bytesRead = 0; + result = -1; + } + } + else + { + uint num2; + int num = ProtoReader.TryReadUInt32Variant(source, out num2); + bytesRead += num; + result = (int)((bytesRead < 0) ? uint.MaxValue : num2); + } + break; + case PrefixStyle.Fixed32: + { + int num3 = source.ReadByte(); + bool flag4 = num3 < 0; + if (flag4) + { + bytesRead = 0; + result = -1; + } + else + { + bytesRead = 4; + result = (num3 | ProtoReader.ReadByteOrThrow(source) << 8 | ProtoReader.ReadByteOrThrow(source) << 16 | ProtoReader.ReadByteOrThrow(source) << 24); + } + break; + } + case PrefixStyle.Fixed32BigEndian: + { + int num4 = source.ReadByte(); + bool flag5 = num4 < 0; + if (flag5) + { + bytesRead = 0; + result = -1; + } + else + { + bytesRead = 4; + result = (num4 << 24 | ProtoReader.ReadByteOrThrow(source) << 16 | ProtoReader.ReadByteOrThrow(source) << 8 | ProtoReader.ReadByteOrThrow(source)); + } + break; + } + default: + throw new ArgumentOutOfRangeException("style"); + } + return result; + } + + private static int TryReadUInt32Variant(Stream source, out uint value) + { + value = 0u; + int num = source.ReadByte(); + bool flag = num < 0; + int result; + if (flag) + { + result = 0; + } + else + { + value = (uint)num; + bool flag2 = (value & 128u) == 0u; + if (flag2) + { + result = 1; + } + else + { + value &= 127u; + num = source.ReadByte(); + bool flag3 = num < 0; + if (flag3) + { + throw ProtoReader.EoF(null); + } + value |= (uint)((uint)(num & 127) << 7); + bool flag4 = (num & 128) == 0; + if (flag4) + { + result = 2; + } + else + { + num = source.ReadByte(); + bool flag5 = num < 0; + if (flag5) + { + throw ProtoReader.EoF(null); + } + value |= (uint)((uint)(num & 127) << 14); + bool flag6 = (num & 128) == 0; + if (flag6) + { + result = 3; + } + else + { + num = source.ReadByte(); + bool flag7 = num < 0; + if (flag7) + { + throw ProtoReader.EoF(null); + } + value |= (uint)((uint)(num & 127) << 21); + bool flag8 = (num & 128) == 0; + if (flag8) + { + result = 4; + } + else + { + num = source.ReadByte(); + bool flag9 = num < 0; + if (flag9) + { + throw ProtoReader.EoF(null); + } + value |= (uint)((uint)num << 28); + bool flag10 = (num & 240) == 0; + if (!flag10) + { + throw new OverflowException(); + } + result = 5; + } + } + } + } + } + return result; + } + + internal static void Seek(Stream source, int count, byte[] buffer) + { + bool canSeek = source.CanSeek; + if (canSeek) + { + source.Seek((long)count, SeekOrigin.Current); + count = 0; + } + else + { + bool flag = buffer != null; + if (flag) + { + int num; + while (count > buffer.Length && (num = source.Read(buffer, 0, buffer.Length)) > 0) + { + count -= num; + } + while (count > 0 && (num = source.Read(buffer, 0, count)) > 0) + { + count -= num; + } + } + else + { + buffer = BufferPool.GetBuffer(); + try + { + int num2; + while (count > buffer.Length && (num2 = source.Read(buffer, 0, buffer.Length)) > 0) + { + count -= num2; + } + while (count > 0 && (num2 = source.Read(buffer, 0, count)) > 0) + { + count -= num2; + } + } + finally + { + BufferPool.ReleaseBufferToPool(ref buffer); + } + } + } + bool flag2 = count > 0; + if (flag2) + { + throw ProtoReader.EoF(null); + } + } + + internal static Exception AddErrorData(Exception exception, ProtoReader source) + { + bool flag = exception != null && source != null && !exception.Data.Contains("protoSource"); + if (flag) + { + exception.Data.Add("protoSource", string.Format("tag={0}; wire-type={1}; offset={2}; depth={3}", new object[] + { + source.fieldNumber, + source.wireType, + source.position, + source.depth + })); + } + return exception; + } + + private static Exception EoF(ProtoReader source) + { + return ProtoReader.AddErrorData(new EndOfStreamException(), source); + } + + public void AppendExtensionData(IExtensible instance) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + IExtension extensionObject = instance.GetExtensionObject(true); + bool commit = false; + Stream stream = extensionObject.BeginAppend(); + try + { + using (ProtoWriter protoWriter = new ProtoWriter(stream, this.model, null)) + { + this.AppendExtensionField(protoWriter); + protoWriter.Close(); + } + commit = true; + } + finally + { + extensionObject.EndAppend(stream, commit); + } + } + + private void AppendExtensionField(ProtoWriter writer) + { + ProtoWriter.WriteFieldHeader(this.fieldNumber, this.wireType, writer); + switch (this.wireType) + { + case WireType.Variant: + case WireType.Fixed64: + case WireType.SignedVariant: + ProtoWriter.WriteInt64(this.ReadInt64(), writer); + return; + case WireType.String: + ProtoWriter.WriteBytes(ProtoReader.AppendBytes(null, this), writer); + return; + case WireType.StartGroup: + { + SubItemToken token = ProtoReader.StartSubItem(this); + SubItemToken token2 = ProtoWriter.StartSubItem(null, writer); + while (this.ReadFieldHeader() > 0) + { + this.AppendExtensionField(writer); + } + ProtoReader.EndSubItem(token, this); + ProtoWriter.EndSubItem(token2, writer); + return; + } + case WireType.Fixed32: + ProtoWriter.WriteInt32(this.ReadInt32(), writer); + return; + } + throw this.CreateWireTypeException(); + } + + public static bool HasSubValue(WireType wireType, ProtoReader source) + { + bool flag = source == null; + if (flag) + { + throw new ArgumentNullException("source"); + } + bool flag2 = source.blockEnd <= source.position || wireType == WireType.EndGroup; + bool result; + if (flag2) + { + result = false; + } + else + { + source.wireType = wireType; + result = true; + } + return result; + } + + internal int GetTypeKey(ref Type type) + { + return this.model.GetKey(ref type); + } + + internal Type DeserializeType(string value) + { + return TypeModel.DeserializeType(this.model, value); + } + + internal void SetRootObject(object value) + { + this.netCache.SetKeyedObject(0, value); + this.trapCount -= 1u; + } + + public static void NoteObject(object value, ProtoReader reader) + { + bool flag = reader == null; + if (flag) + { + throw new ArgumentNullException("reader"); + } + bool flag2 = reader.trapCount > 0u; + if (flag2) + { + reader.netCache.RegisterTrappedObject(value); + reader.trapCount -= 1u; + } + } + + public Type ReadType() + { + return TypeModel.DeserializeType(this.model, this.ReadString()); + } + + internal void TrapNextObject(int newObjectKey) + { + this.trapCount += 1u; + this.netCache.SetKeyedObject(newObjectKey, null); + } + + internal void CheckFullyConsumed() + { + bool flag = this.isFixedLength; + if (flag) + { + bool flag2 = this.dataRemaining != 0; + if (flag2) + { + throw new ProtoException("Incorrect number of bytes consumed"); + } + } + else + { + bool flag3 = this.available != 0; + if (flag3) + { + throw new ProtoException("Unconsumed data left in the buffer; this suggests corrupt input"); + } + } + } + + public static object Merge(ProtoReader parent, object from, object to) + { + bool flag = parent == null; + if (flag) + { + throw new ArgumentNullException("parent"); + } + TypeModel typeModel = parent.Model; + SerializationContext serializationContext = parent.Context; + bool flag2 = typeModel == null; + if (flag2) + { + throw new InvalidOperationException("Types cannot be merged unless a type-model has been specified"); + } + object result; + using (MemoryStream memoryStream = new MemoryStream()) + { + typeModel.Serialize(memoryStream, from, serializationContext); + memoryStream.Position = 0L; + result = typeModel.Deserialize(memoryStream, to, null); + } + return result; + } + + internal static ProtoReader Create(Stream source, TypeModel model, SerializationContext context, int len) + { + ProtoReader recycled = ProtoReader.GetRecycled(); + bool flag = recycled == null; + ProtoReader result; + if (flag) + { + result = new ProtoReader(source, model, context, len); + } + else + { + ProtoReader.Init(recycled, source, model, context, len); + result = recycled; + } + return result; + } + + private static ProtoReader GetRecycled() + { + ProtoReader result = ProtoReader.lastReader; + ProtoReader.lastReader = null; + return result; + } + + internal static void Recycle(ProtoReader reader) + { + bool flag = reader != null; + if (flag) + { + reader.Dispose(); + ProtoReader.lastReader = reader; + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs.meta new file mode 100644 index 00000000..20a81efd --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoReader.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c2861b991d19ced42991a21212bf2e44 +timeCreated: 1611404494 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs new file mode 100644 index 00000000..80039345 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs @@ -0,0 +1,30 @@ +using System; + +namespace ProtoBuf +{ + internal enum ProtoTypeCode + { + Empty, + Unknown, + Boolean = 3, + Char, + SByte, + Byte, + Int16, + UInt16, + Int32, + UInt32, + Int64, + UInt64, + Single, + Double, + Decimal, + DateTime, + String = 18, + TimeSpan = 100, + ByteArray, + Guid, + Uri, + Type + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs.meta new file mode 100644 index 00000000..0c507e5c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoTypeCode.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 40d0908bcdffe8f4781b540b382296b0 +timeCreated: 1611403615 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs new file mode 100644 index 00000000..470c8605 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs @@ -0,0 +1,1102 @@ +using System; +using System.IO; +using System.Text; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + public sealed class ProtoWriter : IDisposable + { + internal NetObjectCache NetCache + { + get + { + return this.netCache; + } + } + + internal WireType WireType + { + get + { + return this.wireType; + } + } + + public SerializationContext Context + { + get + { + return this.context; + } + } + + public TypeModel Model + { + get + { + return this.model; + } + } + + private Stream dest; + + private TypeModel model; + + private readonly NetObjectCache netCache = new NetObjectCache(); + + private int fieldNumber; + + private int flushLock; + + private WireType wireType; + + private int depth = 0; + + private const int RecursionCheckDepth = 25; + + private MutableList recursionStack; + + private readonly SerializationContext context; + + private byte[] ioBuffer; + + private int ioIndex; + + private int position; + + private static readonly UTF8Encoding encoding = new UTF8Encoding(); + + private int packedFieldNumber; + + public static void WriteObject(object value, int key, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + bool flag2 = writer.model == null; + if (flag2) + { + throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); + } + SubItemToken token = ProtoWriter.StartSubItem(value, writer); + bool flag3 = key >= 0; + if (flag3) + { + writer.model.Serialize(key, value, writer); + } + else + { + bool flag4 = writer.model != null && writer.model.TrySerializeAuxiliaryType(writer, value.GetType(), DataFormat.Default, 1, value, false); + if (!flag4) + { + TypeModel.ThrowUnexpectedType(value.GetType()); + } + } + ProtoWriter.EndSubItem(token, writer); + } + + public static void WriteRecursionSafeObject(object value, int key, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + bool flag2 = writer.model == null; + if (flag2) + { + throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); + } + SubItemToken token = ProtoWriter.StartSubItem(null, writer); + writer.model.Serialize(key, value, writer); + ProtoWriter.EndSubItem(token, writer); + } + + internal static void WriteObject(object value, int key, ProtoWriter writer, PrefixStyle style, int fieldNumber) + { + bool flag = writer.model == null; + if (flag) + { + throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); + } + bool flag2 = writer.wireType != WireType.None; + if (flag2) + { + throw ProtoWriter.CreateException(writer); + } + if (style != PrefixStyle.Base128) + { + if (style - PrefixStyle.Fixed32 > 1) + { + throw new ArgumentOutOfRangeException("style"); + } + writer.fieldNumber = 0; + writer.wireType = WireType.Fixed32; + } + else + { + writer.wireType = WireType.String; + writer.fieldNumber = fieldNumber; + bool flag3 = fieldNumber > 0; + if (flag3) + { + ProtoWriter.WriteHeaderCore(fieldNumber, WireType.String, writer); + } + } + SubItemToken token = ProtoWriter.StartSubItem(value, writer, true); + bool flag4 = key < 0; + if (flag4) + { + bool flag5 = !writer.model.TrySerializeAuxiliaryType(writer, value.GetType(), DataFormat.Default, 1, value, false); + if (flag5) + { + TypeModel.ThrowUnexpectedType(value.GetType()); + } + } + else + { + writer.model.Serialize(key, value, writer); + } + ProtoWriter.EndSubItem(token, writer, style); + } + + internal int GetTypeKey(ref Type type) + { + return this.model.GetKey(ref type); + } + + public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + bool flag2 = writer.wireType != WireType.None; + if (flag2) + { + throw new InvalidOperationException(string.Concat(new string[] + { + "Cannot write a ", + wireType.ToString(), + " header until the ", + writer.wireType.ToString(), + " data has been written" + })); + } + bool flag3 = fieldNumber < 0; + if (flag3) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + switch (wireType) + { + case WireType.Variant: + case WireType.Fixed64: + case WireType.String: + case WireType.StartGroup: + case WireType.Fixed32: + case WireType.SignedVariant: + { + bool flag4 = writer.packedFieldNumber == 0; + if (flag4) + { + writer.fieldNumber = fieldNumber; + writer.wireType = wireType; + ProtoWriter.WriteHeaderCore(fieldNumber, wireType, writer); + } + else + { + bool flag5 = writer.packedFieldNumber == fieldNumber; + if (!flag5) + { + throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString()); + } + WireType wireType2 = wireType; + if (wireType2 > WireType.Fixed64 && wireType2 != WireType.Fixed32 && wireType2 != WireType.SignedVariant) + { + throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString()); + } + writer.fieldNumber = fieldNumber; + writer.wireType = wireType; + } + return; + } + } + throw new ArgumentException("Invalid wire-type: " + wireType.ToString(), "wireType"); + } + + internal static void WriteHeaderCore(int fieldNumber, WireType wireType, ProtoWriter writer) + { + uint value = (uint)(fieldNumber << 3 | (int)(wireType & (WireType)7)); + ProtoWriter.WriteUInt32Variant(value, writer); + } + + public static void WriteBytes(byte[] data, ProtoWriter writer) + { + bool flag = data == null; + if (flag) + { + throw new ArgumentNullException("data"); + } + ProtoWriter.WriteBytes(data, 0, data.Length, writer); + } + + public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer) + { + bool flag = data == null; + if (flag) + { + throw new ArgumentNullException("data"); + } + bool flag2 = writer == null; + if (flag2) + { + throw new ArgumentNullException("writer"); + } + switch (writer.wireType) + { + case WireType.Fixed64: + { + bool flag3 = length != 8; + if (flag3) + { + throw new ArgumentException("length"); + } + goto IL_EE; + } + case WireType.String: + { + ProtoWriter.WriteUInt32Variant((uint)length, writer); + writer.wireType = WireType.None; + bool flag4 = length == 0; + if (flag4) + { + return; + } + bool flag5 = writer.flushLock != 0 || length <= writer.ioBuffer.Length; + if (flag5) + { + goto IL_EE; + } + ProtoWriter.Flush(writer); + writer.dest.Write(data, offset, length); + writer.position += length; + return; + } + case WireType.Fixed32: + { + bool flag6 = length != 4; + if (flag6) + { + throw new ArgumentException("length"); + } + goto IL_EE; + } + } + throw ProtoWriter.CreateException(writer); + IL_EE: + ProtoWriter.DemandSpace(length, writer); + Helpers.BlockCopy(data, offset, writer.ioBuffer, writer.ioIndex, length); + ProtoWriter.IncrementedAndReset(length, writer); + } + + private static void CopyRawFromStream(Stream source, ProtoWriter writer) + { + byte[] array = writer.ioBuffer; + int num = array.Length - writer.ioIndex; + int num2 = 1; + while (num > 0 && (num2 = source.Read(array, writer.ioIndex, num)) > 0) + { + writer.ioIndex += num2; + writer.position += num2; + num -= num2; + } + bool flag = num2 <= 0; + if (!flag) + { + bool flag2 = writer.flushLock == 0; + if (flag2) + { + ProtoWriter.Flush(writer); + while ((num2 = source.Read(array, 0, array.Length)) > 0) + { + writer.dest.Write(array, 0, num2); + writer.position += num2; + } + } + else + { + for (;;) + { + ProtoWriter.DemandSpace(128, writer); + bool flag3 = (num2 = source.Read(writer.ioBuffer, writer.ioIndex, writer.ioBuffer.Length - writer.ioIndex)) <= 0; + if (flag3) + { + break; + } + writer.position += num2; + writer.ioIndex += num2; + } + } + } + } + + private static void IncrementedAndReset(int length, ProtoWriter writer) + { + Helpers.DebugAssert(length >= 0); + writer.ioIndex += length; + writer.position += length; + writer.wireType = WireType.None; + } + + public static SubItemToken StartSubItem(object instance, ProtoWriter writer) + { + return ProtoWriter.StartSubItem(instance, writer, false); + } + + private void CheckRecursionStackAndPush(object instance) + { + bool flag = this.recursionStack == null; + if (flag) + { + this.recursionStack = new MutableList(); + } + else + { + int num = 0; + bool flag2 = instance != null && (num = this.recursionStack.IndexOfReference(instance)) >= 0; + if (flag2) + { + Helpers.DebugWriteLine("Stack:"); + foreach (object obj in this.recursionStack) + { + Helpers.DebugWriteLine((obj == null) ? "" : obj.ToString()); + } + Helpers.DebugWriteLine((instance == null) ? "" : instance.ToString()); + throw new ProtoException("Possible recursion detected (offset: " + (this.recursionStack.Count - num).ToString() + " level(s)): " + instance.ToString()); + } + } + this.recursionStack.Add(instance); + } + + private void PopRecursionStack() + { + this.recursionStack.RemoveLast(); + } + + private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + int num = writer.depth + 1; + writer.depth = num; + bool flag2 = num > 25; + if (flag2) + { + writer.CheckRecursionStackAndPush(instance); + } + bool flag3 = writer.packedFieldNumber != 0; + if (flag3) + { + throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding"); + } + switch (writer.wireType) + { + case WireType.String: + { + bool flag4 = writer.model != null && writer.model.ForwardsOnly; + if (flag4) + { + throw new ProtoException("Should not be buffering data"); + } + writer.wireType = WireType.None; + ProtoWriter.DemandSpace(32, writer); + writer.flushLock++; + writer.position++; + num = writer.ioIndex; + writer.ioIndex = num + 1; + return new SubItemToken(num); + } + case WireType.StartGroup: + writer.wireType = WireType.None; + return new SubItemToken(-writer.fieldNumber); + case WireType.Fixed32: + { + bool flag5 = !allowFixed; + if (flag5) + { + throw ProtoWriter.CreateException(writer); + } + ProtoWriter.DemandSpace(32, writer); + writer.flushLock++; + SubItemToken result = new SubItemToken(writer.ioIndex); + ProtoWriter.IncrementedAndReset(4, writer); + return result; + } + } + throw ProtoWriter.CreateException(writer); + } + + public static void EndSubItem(SubItemToken token, ProtoWriter writer) + { + ProtoWriter.EndSubItem(token, writer, PrefixStyle.Base128); + } + + private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + bool flag2 = writer.wireType != WireType.None; + if (flag2) + { + throw ProtoWriter.CreateException(writer); + } + int value = token.value; + bool flag3 = writer.depth <= 0; + if (flag3) + { + throw ProtoWriter.CreateException(writer); + } + int num = writer.depth; + writer.depth = num - 1; + bool flag4 = num > 25; + if (flag4) + { + writer.PopRecursionStack(); + } + writer.packedFieldNumber = 0; + bool flag5 = value < 0; + if (flag5) + { + ProtoWriter.WriteHeaderCore(-value, WireType.EndGroup, writer); + writer.wireType = WireType.None; + } + else + { + switch (style) + { + case PrefixStyle.Base128: + { + int num2 = writer.ioIndex - value - 1; + int num3 = 0; + uint num4 = (uint)num2; + while ((num4 >>= 7) > 0u) + { + num3++; + } + bool flag6 = num3 == 0; + if (flag6) + { + writer.ioBuffer[value] = (byte)(num2 & 127); + } + else + { + ProtoWriter.DemandSpace(num3, writer); + byte[] array = writer.ioBuffer; + Helpers.BlockCopy(array, value + 1, array, value + 1 + num3, num2); + num4 = (uint)num2; + do + { + array[value++] = (byte)((num4 & 127u) | 128u); + } + while ((num4 >>= 7) > 0u); + array[value - 1] = (byte)((int)array[value - 1] & -129); + writer.position += num3; + writer.ioIndex += num3; + } + break; + } + case PrefixStyle.Fixed32: + { + int num2 = writer.ioIndex - value - 4; + ProtoWriter.WriteInt32ToBuffer(num2, writer.ioBuffer, value); + break; + } + case PrefixStyle.Fixed32BigEndian: + { + int num2 = writer.ioIndex - value - 4; + byte[] array2 = writer.ioBuffer; + ProtoWriter.WriteInt32ToBuffer(num2, array2, value); + byte b = array2[value]; + array2[value] = array2[value + 3]; + array2[value + 3] = b; + b = array2[value + 1]; + array2[value + 1] = array2[value + 2]; + array2[value + 2] = b; + break; + } + default: + throw new ArgumentOutOfRangeException("style"); + } + num = writer.flushLock - 1; + writer.flushLock = num; + bool flag7 = num == 0 && writer.ioIndex >= 1024; + if (flag7) + { + ProtoWriter.Flush(writer); + } + } + } + + public ProtoWriter(Stream dest, TypeModel model, SerializationContext context) + { + bool flag = dest == null; + if (flag) + { + throw new ArgumentNullException("dest"); + } + bool flag2 = !dest.CanWrite; + if (flag2) + { + throw new ArgumentException("Cannot write to stream", "dest"); + } + this.dest = dest; + this.ioBuffer = BufferPool.GetBuffer(); + this.model = model; + this.wireType = WireType.None; + bool flag3 = context == null; + if (flag3) + { + context = SerializationContext.Default; + } + else + { + context.Freeze(); + } + this.context = context; + } + + void IDisposable.Dispose() + { + this.Dispose(); + } + + private void Dispose() + { + bool flag = this.dest != null; + if (flag) + { + ProtoWriter.Flush(this); + this.dest = null; + } + this.model = null; + BufferPool.ReleaseBufferToPool(ref this.ioBuffer); + } + + internal static int GetPosition(ProtoWriter writer) + { + return writer.position; + } + + private static void DemandSpace(int required, ProtoWriter writer) + { + bool flag = writer.ioBuffer.Length - writer.ioIndex < required; + if (flag) + { + bool flag2 = writer.flushLock == 0; + if (flag2) + { + ProtoWriter.Flush(writer); + bool flag3 = writer.ioBuffer.Length - writer.ioIndex >= required; + if (flag3) + { + return; + } + } + BufferPool.ResizeAndFlushLeft(ref writer.ioBuffer, required + writer.ioIndex, 0, writer.ioIndex); + } + } + + public void Close() + { + bool flag = this.depth != 0 || this.flushLock != 0; + if (flag) + { + throw new InvalidOperationException("Unable to close stream in an incomplete state"); + } + this.Dispose(); + } + + internal void CheckDepthFlushlock() + { + bool flag = this.depth != 0 || this.flushLock != 0; + if (flag) + { + throw new InvalidOperationException("The writer is in an incomplete state"); + } + } + + internal static void Flush(ProtoWriter writer) + { + bool flag = writer.flushLock == 0 && writer.ioIndex != 0; + if (flag) + { + writer.dest.Write(writer.ioBuffer, 0, writer.ioIndex); + writer.ioIndex = 0; + } + } + + private static void WriteUInt32Variant(uint value, ProtoWriter writer) + { + ProtoWriter.DemandSpace(5, writer); + int num = 0; + do + { + byte[] array = writer.ioBuffer; + int num2 = writer.ioIndex; + writer.ioIndex = num2 + 1; + array[num2] = (byte)((value & 127u) | 128u); + num++; + } + while ((value >>= 7) > 0u); + byte[] array2 = writer.ioBuffer; + int num3 = writer.ioIndex - 1; + array2[num3] &= 127; + writer.position += num; + } + + internal static uint Zig(int value) + { + return (uint)(value << 1 ^ value >> 31); + } + + internal static ulong Zig(long value) + { + return (ulong)(value << 1 ^ value >> 63); + } + + private static void WriteUInt64Variant(ulong value, ProtoWriter writer) + { + ProtoWriter.DemandSpace(10, writer); + int num = 0; + do + { + byte[] array = writer.ioBuffer; + int num2 = writer.ioIndex; + writer.ioIndex = num2 + 1; + array[num2] = (byte)((value & 127UL) | 128UL); + num++; + } + while ((value >>= 7) > 0UL); + byte[] array2 = writer.ioBuffer; + int num3 = writer.ioIndex - 1; + array2[num3] &= 127; + writer.position += num; + } + + public static void WriteString(string value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + bool flag2 = writer.wireType != WireType.String; + if (flag2) + { + throw ProtoWriter.CreateException(writer); + } + bool flag3 = value == null; + if (flag3) + { + throw new ArgumentNullException("value"); + } + int length = value.Length; + bool flag4 = length == 0; + if (flag4) + { + ProtoWriter.WriteUInt32Variant(0u, writer); + writer.wireType = WireType.None; + } + else + { + int byteCount = ProtoWriter.encoding.GetByteCount(value); + ProtoWriter.WriteUInt32Variant((uint)byteCount, writer); + ProtoWriter.DemandSpace(byteCount, writer); + int bytes = ProtoWriter.encoding.GetBytes(value, 0, value.Length, writer.ioBuffer, writer.ioIndex); + Helpers.DebugAssert(byteCount == bytes); + ProtoWriter.IncrementedAndReset(bytes, writer); + } + } + + public static void WriteUInt64(ulong value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType != WireType.Variant) + { + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw ProtoWriter.CreateException(writer); + } + ProtoWriter.WriteUInt32(checked((uint)value), writer); + } + else + { + ProtoWriter.WriteInt64((long)value, writer); + } + } + else + { + ProtoWriter.WriteUInt64Variant(value, writer); + writer.wireType = WireType.None; + } + } + + public static void WriteInt64(long value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType <= WireType.Fixed64) + { + if (wireType == WireType.Variant) + { + bool flag2 = value >= 0L; + if (flag2) + { + ProtoWriter.WriteUInt64Variant((ulong)value, writer); + writer.wireType = WireType.None; + } + else + { + ProtoWriter.DemandSpace(10, writer); + byte[] array = writer.ioBuffer; + int num = writer.ioIndex; + array[num] = (byte)(value | 128L); + array[num + 1] = (byte)((int)(value >> 7) | 128); + array[num + 2] = (byte)((int)(value >> 14) | 128); + array[num + 3] = (byte)((int)(value >> 21) | 128); + array[num + 4] = (byte)((int)(value >> 28) | 128); + array[num + 5] = (byte)((int)(value >> 35) | 128); + array[num + 6] = (byte)((int)(value >> 42) | 128); + array[num + 7] = (byte)((int)(value >> 49) | 128); + array[num + 8] = (byte)((int)(value >> 56) | 128); + array[num + 9] = 1; + ProtoWriter.IncrementedAndReset(10, writer); + } + return; + } + if (wireType == WireType.Fixed64) + { + ProtoWriter.DemandSpace(8, writer); + byte[] array = writer.ioBuffer; + int num = writer.ioIndex; + array[num] = (byte)value; + array[num + 1] = (byte)(value >> 8); + array[num + 2] = (byte)(value >> 16); + array[num + 3] = (byte)(value >> 24); + array[num + 4] = (byte)(value >> 32); + array[num + 5] = (byte)(value >> 40); + array[num + 6] = (byte)(value >> 48); + array[num + 7] = (byte)(value >> 56); + ProtoWriter.IncrementedAndReset(8, writer); + return; + } + } + else + { + if (wireType == WireType.Fixed32) + { + ProtoWriter.WriteInt32(checked((int)value), writer); + return; + } + if (wireType == WireType.SignedVariant) + { + ProtoWriter.WriteUInt64Variant(ProtoWriter.Zig(value), writer); + writer.wireType = WireType.None; + return; + } + } + throw ProtoWriter.CreateException(writer); + } + + public static void WriteUInt32(uint value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType != WireType.Variant) + { + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw ProtoWriter.CreateException(writer); + } + ProtoWriter.WriteInt32((int)value, writer); + } + else + { + ProtoWriter.WriteInt64((long)value, writer); + } + } + else + { + ProtoWriter.WriteUInt32Variant(value, writer); + writer.wireType = WireType.None; + } + } + + public static void WriteInt16(short value, ProtoWriter writer) + { + ProtoWriter.WriteInt32((int)value, writer); + } + + public static void WriteUInt16(ushort value, ProtoWriter writer) + { + ProtoWriter.WriteUInt32((uint)value, writer); + } + + public static void WriteByte(byte value, ProtoWriter writer) + { + ProtoWriter.WriteUInt32((uint)value, writer); + } + + public static void WriteSByte(sbyte value, ProtoWriter writer) + { + ProtoWriter.WriteInt32((int)value, writer); + } + + private static void WriteInt32ToBuffer(int value, byte[] buffer, int index) + { + buffer[index] = (byte)value; + buffer[index + 1] = (byte)(value >> 8); + buffer[index + 2] = (byte)(value >> 16); + buffer[index + 3] = (byte)(value >> 24); + } + + public static void WriteInt32(int value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType <= WireType.Fixed64) + { + if (wireType == WireType.Variant) + { + bool flag2 = value >= 0; + if (flag2) + { + ProtoWriter.WriteUInt32Variant((uint)value, writer); + writer.wireType = WireType.None; + } + else + { + ProtoWriter.DemandSpace(10, writer); + byte[] array = writer.ioBuffer; + int num = writer.ioIndex; + array[num] = (byte)(value | 128); + array[num + 1] = (byte)(value >> 7 | 128); + array[num + 2] = (byte)(value >> 14 | 128); + array[num + 3] = (byte)(value >> 21 | 128); + array[num + 4] = (byte)(value >> 28 | 128); + array[num + 5] = (array[num + 6] = (array[num + 7] = (array[num + 8] = byte.MaxValue))); + array[num + 9] = 1; + ProtoWriter.IncrementedAndReset(10, writer); + } + return; + } + if (wireType == WireType.Fixed64) + { + ProtoWriter.DemandSpace(8, writer); + byte[] array = writer.ioBuffer; + int num = writer.ioIndex; + array[num] = (byte)value; + array[num + 1] = (byte)(value >> 8); + array[num + 2] = (byte)(value >> 16); + array[num + 3] = (byte)(value >> 24); + array[num + 4] = (array[num + 5] = (array[num + 6] = (array[num + 7] = 0))); + ProtoWriter.IncrementedAndReset(8, writer); + return; + } + } + else + { + if (wireType == WireType.Fixed32) + { + ProtoWriter.DemandSpace(4, writer); + ProtoWriter.WriteInt32ToBuffer(value, writer.ioBuffer, writer.ioIndex); + ProtoWriter.IncrementedAndReset(4, writer); + return; + } + if (wireType == WireType.SignedVariant) + { + ProtoWriter.WriteUInt32Variant(ProtoWriter.Zig(value), writer); + writer.wireType = WireType.None; + return; + } + } + throw ProtoWriter.CreateException(writer); + } + + public unsafe static void WriteDouble(double value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw ProtoWriter.CreateException(writer); + } + float value2 = (float)value; + bool flag2 = Helpers.IsInfinity(value2) && !Helpers.IsInfinity(value); + if (flag2) + { + throw new OverflowException(); + } + ProtoWriter.WriteSingle(value2, writer); + } + else + { + ProtoWriter.WriteInt64(*(long*)(&value), writer); + } + } + + public unsafe static void WriteSingle(float value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + WireType wireType = writer.wireType; + if (wireType != WireType.Fixed64) + { + if (wireType != WireType.Fixed32) + { + throw ProtoWriter.CreateException(writer); + } + ProtoWriter.WriteInt32(*(int*)(&value), writer); + } + else + { + ProtoWriter.WriteDouble((double)value, writer); + } + } + + public static void ThrowEnumException(ProtoWriter writer, object enumValue) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + string str = (enumValue == null) ? "" : (enumValue.GetType().FullName + "." + enumValue.ToString()); + throw new ProtoException("No wire-value is mapped to the enum " + str + " at position " + writer.position.ToString()); + } + + internal static Exception CreateException(ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + return new ProtoException("Invalid serialization operation with wire-type " + writer.wireType.ToString() + " at position " + writer.position.ToString()); + } + + public static void WriteBoolean(bool value, ProtoWriter writer) + { + ProtoWriter.WriteUInt32(value ? 1u : 0u, writer); + } + + public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + bool flag2 = writer == null; + if (flag2) + { + throw new ArgumentNullException("writer"); + } + bool flag3 = writer.wireType != WireType.None; + if (flag3) + { + throw ProtoWriter.CreateException(writer); + } + IExtension extensionObject = instance.GetExtensionObject(false); + bool flag4 = extensionObject != null; + if (flag4) + { + Stream stream = extensionObject.BeginQuery(); + try + { + ProtoWriter.CopyRawFromStream(stream, writer); + } + finally + { + extensionObject.EndQuery(stream); + } + } + } + + public static void SetPackedField(int fieldNumber, ProtoWriter writer) + { + bool flag = fieldNumber <= 0; + if (flag) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + bool flag2 = writer == null; + if (flag2) + { + throw new ArgumentNullException("writer"); + } + writer.packedFieldNumber = fieldNumber; + } + + internal string SerializeType(Type type) + { + return TypeModel.SerializeType(this.model, type); + } + + public void SetRootObject(object value) + { + this.NetCache.SetKeyedObject(0, value); + } + + public static void WriteType(Type value, ProtoWriter writer) + { + bool flag = writer == null; + if (flag) + { + throw new ArgumentNullException("writer"); + } + ProtoWriter.WriteString(writer.SerializeType(value), writer); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs.meta new file mode 100644 index 00000000..d48ab681 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/ProtoWriter.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 8cebcb43dfaf89a44a4f76b395b89452 +timeCreated: 1611404102 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs new file mode 100644 index 00000000..1259b708 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs @@ -0,0 +1,57 @@ +using System; + +namespace ProtoBuf +{ + public sealed class SerializationContext + { + public object Context + { + get + { + return this.context; + } + set + { + bool flag = this.context != value; + if (flag) + { + this.ThrowIfFrozen(); + this.context = value; + } + } + } + + internal static SerializationContext Default + { + get + { + return SerializationContext.@default; + } + } + + private bool frozen; + + private object context; + + private static readonly SerializationContext @default = new SerializationContext(); + + internal void Freeze() + { + this.frozen = true; + } + + private void ThrowIfFrozen() + { + bool flag = this.frozen; + if (flag) + { + throw new InvalidOperationException("The serialization-context cannot be changed once it is in use"); + } + } + + static SerializationContext() + { + SerializationContext.@default.Freeze(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs.meta new file mode 100644 index 00000000..bee2c1d5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/SerializationContext.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 319befc067bfd6442bc8aaae3dd8e140 +timeCreated: 1611403546 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs new file mode 100644 index 00000000..c80cdea0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs @@ -0,0 +1,268 @@ +using System; +using System.Collections.Generic; +using System.IO; +using ProtoBuf.Meta; + +namespace ProtoBuf +{ + public static class Serializer + { + private static bool useMultiThread = false; + + public static bool isSkipProtoIgnore = false; + + private const string ProtoBinaryField = "proto"; + + public const int ListItemTag = 1; + + public static class NonGeneric + { + public static object DeepClone(object instance) + { + return (instance == null) ? null : RuntimeTypeModel.Default.DeepClone(instance); + } + + public static void Serialize(Stream dest, object instance) + { + bool flag = instance != null; + if (flag) + { + RuntimeTypeModel.Default.Serialize(dest, instance); + } + } + + public static object Deserialize(Type type, Stream source) + { + return RuntimeTypeModel.Default.Deserialize(source, null, type); + } + + public static object Merge(Stream source, object instance) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + return RuntimeTypeModel.Default.Deserialize(source, instance, instance.GetType(), null); + } + + public static void SerializeWithLengthPrefix(Stream destination, object instance, PrefixStyle style, int fieldNumber) + { + bool flag = instance == null; + if (flag) + { + throw new ArgumentNullException("instance"); + } + RuntimeTypeModel @default = RuntimeTypeModel.Default; + @default.SerializeWithLengthPrefix(destination, instance, @default.MapType(instance.GetType()), style, fieldNumber); + } + + public static bool TryDeserializeWithLengthPrefix(Stream source, PrefixStyle style, Serializer.TypeResolver resolver, out object value) + { + value = RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, null, null, style, 0, resolver); + return value != null; + } + + public static bool CanSerialize(Type type) + { + return RuntimeTypeModel.Default.IsDefined(type); + } + } + + public static class GlobalOptions + { + [Obsolete("Please use RuntimeTypeModel.Default.InferTagFromNameDefault instead (or on a per-model basis)", false)] + public static bool InferTagFromName + { + get + { + return RuntimeTypeModel.Default.InferTagFromNameDefault; + } + set + { + RuntimeTypeModel.Default.InferTagFromNameDefault = value; + } + } + } + + public delegate Type TypeResolver(int fieldNumber); + + public static string GetProto() + { + return RuntimeTypeModel.Default.GetSchema(RuntimeTypeModel.Default.MapType(typeof(T))); + } + + public static void SetMultiThread(bool multiThread) + { + Serializer.useMultiThread = multiThread; + } + + public static void SetSkipProtoIgnore(bool skipProtoIgnore) + { + Serializer.isSkipProtoIgnore = skipProtoIgnore; + } + + public static T DeepClone(T instance) + { + bool flag = instance == null; + T result; + if (flag) + { + result = instance; + } + else + { + bool flag2 = Serializer.useMultiThread; + if (flag2) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + RuntimeTypeModel obj = @default; + lock (obj) + { + return (T)((object)@default.DeepClone(instance)); + } + } + result = (T)((object)RuntimeTypeModel.Default.DeepClone(instance)); + } + return result; + } + + public static T Merge(Stream source, T instance) + { + bool flag = Serializer.useMultiThread; + if (flag) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + RuntimeTypeModel obj = @default; + lock (obj) + { + return (T)((object)@default.Deserialize(source, instance, typeof(T))); + } + } + return (T)((object)RuntimeTypeModel.Default.Deserialize(source, instance, typeof(T))); + } + + public static T Deserialize(Stream source) + { + bool flag = Serializer.useMultiThread; + if (flag) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + RuntimeTypeModel obj = @default; + lock (obj) + { + return (T)((object)@default.Deserialize(source, null, typeof(T))); + } + } + return (T)((object)RuntimeTypeModel.Default.Deserialize(source, null, typeof(T))); + } + + public static void Serialize(Stream destination, T instance) + { + bool flag = instance != null; + if (flag) + { + bool flag2 = Serializer.useMultiThread; + if (flag2) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + RuntimeTypeModel obj = @default; + lock (obj) + { + @default.Serialize(destination, instance); + } + } + else + { + RuntimeTypeModel.Default.Serialize(destination, instance); + } + } + } + + public static void Clear() + { + bool flag = Serializer.useMultiThread; + if (flag) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + RuntimeTypeModel obj = @default; + lock (obj) + { + RuntimeTypeModel.Default.Clear(); + } + } + } + + public static TTo ChangeType(TFrom instance) + { + TTo result; + using (MemoryStream memoryStream = new MemoryStream()) + { + Serializer.Serialize(memoryStream, instance); + memoryStream.Position = 0L; + result = Serializer.Deserialize(memoryStream); + } + return result; + } + + public static void PrepareSerializer() + { + } + + public static IEnumerable DeserializeItems(Stream source, PrefixStyle style, int fieldNumber) + { + return RuntimeTypeModel.Default.DeserializeItems(source, style, fieldNumber); + } + + public static T DeserializeWithLengthPrefix(Stream source, PrefixStyle style) + { + return Serializer.DeserializeWithLengthPrefix(source, style, 0); + } + + public static T DeserializeWithLengthPrefix(Stream source, PrefixStyle style, int fieldNumber) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + return (T)((object)@default.DeserializeWithLengthPrefix(source, null, @default.MapType(typeof(T)), style, fieldNumber)); + } + + public static T MergeWithLengthPrefix(Stream source, T instance, PrefixStyle style) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + return (T)((object)@default.DeserializeWithLengthPrefix(source, instance, @default.MapType(typeof(T)), style, 0)); + } + + public static void SerializeWithLengthPrefix(Stream destination, T instance, PrefixStyle style) + { + Serializer.SerializeWithLengthPrefix(destination, instance, style, 0); + } + + public static void SerializeWithLengthPrefix(Stream destination, T instance, PrefixStyle style, int fieldNumber) + { + RuntimeTypeModel @default = RuntimeTypeModel.Default; + @default.SerializeWithLengthPrefix(destination, instance, @default.MapType(typeof(T)), style, fieldNumber); + } + + public static bool TryReadLengthPrefix(Stream source, PrefixStyle style, out int length) + { + int num; + int num2; + length = ProtoReader.ReadLengthPrefix(source, false, style, out num, out num2); + return num2 > 0; + } + + public static bool TryReadLengthPrefix(byte[] buffer, int index, int count, PrefixStyle style, out int length) + { + bool result; + using (Stream stream = new MemoryStream(buffer, index, count)) + { + result = Serializer.TryReadLengthPrefix(stream, style, out length); + } + return result; + } + + public static void FlushPool() + { + BufferPool.Flush(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs.meta new file mode 100644 index 00000000..f04470b3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ee0c523c5c10b2346acfce15319ae03f +timeCreated: 1611404794 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers.meta new file mode 100644 index 00000000..c6dff761 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c248e27ce1181c040af92086667ee0e6 +folderAsset: yes +timeCreated: 1611402943 +licenseType: Free +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs new file mode 100644 index 00000000..9634fafb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs @@ -0,0 +1,172 @@ +using System; +using System.Collections; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class ArrayDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.arrayType; + } + } + + public override bool RequiresOldValue + { + get + { + return this.AppendToCollection; + } + } + + public override bool ReturnsValue + { + get + { + return true; + } + } + + private bool AppendToCollection + { + get + { + return (this.options & 2) == 0; + } + } + + private bool SupportNull + { + get + { + return (this.options & 4) > 0; + } + } + + private readonly int fieldNumber; + + private const byte OPTIONS_WritePacked = 1; + + private const byte OPTIONS_OverwriteList = 2; + + private const byte OPTIONS_SupportNull = 4; + + private readonly byte options; + + private readonly WireType packedWireType; + + private readonly Type arrayType; + + private readonly Type itemType; + + public ArrayDecorator(TypeModel model, IProtoSerializer tail, int fieldNumber, bool writePacked, WireType packedWireType, Type arrayType, bool overwriteList, bool supportNull) : base(tail) + { + Helpers.DebugAssert(arrayType != null, "arrayType should be non-null"); + Helpers.DebugAssert(arrayType.IsArray && arrayType.GetArrayRank() == 1, "should be single-dimension array; " + arrayType.FullName); + this.itemType = arrayType.GetElementType(); + Type type = supportNull ? this.itemType : (Helpers.GetUnderlyingType(this.itemType) ?? this.itemType); + Helpers.DebugAssert(type == this.Tail.ExpectedType, "invalid tail"); + Helpers.DebugAssert(this.Tail.ExpectedType != model.MapType(typeof(byte)), "Should have used BlobSerializer"); + bool flag = (writePacked || packedWireType != WireType.None) && fieldNumber <= 0; + if (flag) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + bool flag2 = !ListDecorator.CanPack(packedWireType); + if (flag2) + { + if (writePacked) + { + throw new InvalidOperationException("Only simple data-types can use packed encoding"); + } + packedWireType = WireType.None; + } + this.fieldNumber = fieldNumber; + this.packedWireType = packedWireType; + if (writePacked) + { + this.options |= 1; + } + if (overwriteList) + { + this.options |= 2; + } + if (supportNull) + { + this.options |= 4; + } + this.arrayType = arrayType; + } + + public override void Write(object value, ProtoWriter dest) + { + IList list = (IList)value; + int count = list.Count; + bool flag = (this.options & 1) > 0; + bool flag2 = flag; + SubItemToken token; + if (flag2) + { + ProtoWriter.WriteFieldHeader(this.fieldNumber, WireType.String, dest); + token = ProtoWriter.StartSubItem(value, dest); + ProtoWriter.SetPackedField(this.fieldNumber, dest); + } + else + { + token = default(SubItemToken); + } + bool flag3 = !this.SupportNull; + for (int i = 0; i < count; i++) + { + object obj = list[i]; + bool flag4 = flag3 && obj == null; + if (flag4) + { + throw new NullReferenceException(); + } + this.Tail.Write(obj, dest); + } + bool flag5 = flag; + if (flag5) + { + ProtoWriter.EndSubItem(token, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + int field = source.FieldNumber; + BasicList basicList = new BasicList(); + bool flag = this.packedWireType != WireType.None && source.WireType == WireType.String; + if (flag) + { + SubItemToken token = ProtoReader.StartSubItem(source); + while (ProtoReader.HasSubValue(this.packedWireType, source)) + { + basicList.Add(this.Tail.Read(null, source)); + } + ProtoReader.EndSubItem(token, source); + } + else + { + do + { + basicList.Add(this.Tail.Read(null, source)); + } + while (source.TryReadFieldHeader(field)); + } + int num = this.AppendToCollection ? ((value == null) ? 0 : ((Array)value).Length) : 0; + Array array = Array.CreateInstance(this.itemType, num + basicList.Count); + bool flag2 = num != 0; + if (flag2) + { + ((Array)value).CopyTo(array, 0); + } + basicList.CopyTo(array, num); + return array; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs.meta new file mode 100644 index 00000000..4118f71e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ArrayDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: cfb085ae7c0ba154c8a66f748221079a +timeCreated: 1611404582 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs new file mode 100644 index 00000000..b249fe6c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs @@ -0,0 +1,51 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class BlobSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return BlobSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return !this.overwriteList; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(byte[]); + + private readonly bool overwriteList; + + public BlobSerializer(TypeModel model, bool overwriteList) + { + this.overwriteList = overwriteList; + } + + public object Read(object value, ProtoReader source) + { + return ProtoReader.AppendBytes(this.overwriteList ? null : ((byte[])value), source); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteBytes((byte[])value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs.meta new file mode 100644 index 00000000..b521ab6e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BlobSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 017be01ffdc177044beb3e9b4ecba537 +timeCreated: 1611402953 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs new file mode 100644 index 00000000..93f5b63c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class BooleanSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return BooleanSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(bool); + + public BooleanSerializer(TypeModel model) + { + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteBoolean((bool)value, dest); + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadBoolean(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs.meta new file mode 100644 index 00000000..f809b897 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/BooleanSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 649d4d3ef34c60e48be87bc1648abf7b +timeCreated: 1611403848 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs new file mode 100644 index 00000000..5699af9a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class ByteSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return ByteSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(byte); + + public ByteSerializer(TypeModel model) + { + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteByte((byte)value, dest); + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadByte(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs.meta new file mode 100644 index 00000000..730f66c9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ByteSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c9a349c90850d3b479ef0b631a202e04 +timeCreated: 1611404539 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs new file mode 100644 index 00000000..f2a9867a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs @@ -0,0 +1,33 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class CharSerializer : UInt16Serializer + { + public override Type ExpectedType + { + get + { + return CharSerializer.expectedType; + } + } + + private static readonly Type expectedType = typeof(char); + + public CharSerializer(TypeModel model) : base(model) + { + } + + public override void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteUInt16((ushort)((char)value), dest); + } + + public override object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return (char)source.ReadUInt16(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs.meta new file mode 100644 index 00000000..79753d83 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/CharSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 8a2711f42e4488d43a40e0ae660ff0fc +timeCreated: 1611404090 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs new file mode 100644 index 00000000..47895725 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class DateTimeSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return DateTimeSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(DateTime); + + public DateTimeSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return BclHelpers.ReadDateTime(source); + } + + public void Write(object value, ProtoWriter dest) + { + BclHelpers.WriteDateTime((DateTime)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs.meta new file mode 100644 index 00000000..706f3b5e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DateTimeSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 364d58f505fc4e64b8e0810ce3ab8b2f +timeCreated: 1611403562 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs new file mode 100644 index 00000000..fd6c3ceb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class DecimalSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return DecimalSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(decimal); + + public DecimalSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return BclHelpers.ReadDecimal(source); + } + + public void Write(object value, ProtoWriter dest) + { + BclHelpers.WriteDecimal((decimal)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs.meta new file mode 100644 index 00000000..f224e2b1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DecimalSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 644402a116273d14d938548871680373 +timeCreated: 1611403847 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs new file mode 100644 index 00000000..cbbe2821 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs @@ -0,0 +1,64 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class DefaultValueDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.Tail.ExpectedType; + } + } + + public override bool RequiresOldValue + { + get + { + return this.Tail.RequiresOldValue; + } + } + + public override bool ReturnsValue + { + get + { + return this.Tail.ReturnsValue; + } + } + + private readonly object defaultValue; + + public DefaultValueDecorator(TypeModel model, object defaultValue, IProtoSerializer tail) : base(tail) + { + bool flag = defaultValue == null; + if (flag) + { + throw new ArgumentNullException("defaultValue"); + } + Type type = model.MapType(defaultValue.GetType()); + bool flag2 = type != tail.ExpectedType; + if (flag2) + { + throw new ArgumentException("Default value is of incorrect type", "defaultValue"); + } + this.defaultValue = defaultValue; + } + + public override void Write(object value, ProtoWriter dest) + { + bool flag = !object.Equals(value, this.defaultValue); + if (flag) + { + this.Tail.Write(value, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + return this.Tail.Read(value, source); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs.meta new file mode 100644 index 00000000..d7ed0ccf --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DefaultValueDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c318dd759689fa24fa949fbac543b491 +timeCreated: 1611404496 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs new file mode 100644 index 00000000..fa250b9b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class DoubleSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return DoubleSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(double); + + public DoubleSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadDouble(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteDouble((double)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs.meta new file mode 100644 index 00000000..14abd32a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/DoubleSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: be222b20076978a42b534a41d4fffc33 +timeCreated: 1611404458 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs new file mode 100644 index 00000000..3136c29e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs @@ -0,0 +1,213 @@ +using System; +using XUtliPoolLib; + +namespace ProtoBuf.Serializers +{ + internal sealed class EnumSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return this.enumType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private readonly Type enumType; + + private readonly EnumSerializer.EnumPair[] map; + + public struct EnumPair + { + public readonly object RawValue; + + public readonly Enum TypedValue; + + public readonly int WireValue; + + public EnumPair(int wireValue, object raw, Type type) + { + this.WireValue = wireValue; + this.RawValue = raw; + this.TypedValue = (Enum)Enum.ToObject(type, raw); + } + } + + public EnumSerializer(Type enumType, EnumSerializer.EnumPair[] map) + { + bool flag = enumType == null; + if (flag) + { + throw new ArgumentNullException("enumType"); + } + this.enumType = enumType; + this.map = map; + bool flag2 = map != null; + if (flag2) + { + for (int i = 1; i < map.Length; i++) + { + for (int j = 0; j < i; j++) + { + bool flag3 = map[i].WireValue == map[j].WireValue && !object.Equals(map[i].RawValue, map[j].RawValue); + if (flag3) + { + throw new ProtoException("Multiple enums with wire-value " + map[i].WireValue.ToString()); + } + bool flag4 = object.Equals(map[i].RawValue, map[j].RawValue) && map[i].WireValue != map[j].WireValue; + if (flag4) + { + throw new ProtoException("Multiple enums with deserialized-value " + map[i].RawValue); + } + } + } + } + } + + private ProtoTypeCode GetTypeCode() + { + Type underlyingType = Helpers.GetUnderlyingType(this.enumType); + bool flag = underlyingType == null; + if (flag) + { + underlyingType = this.enumType; + } + return Helpers.GetTypeCode(underlyingType); + } + + private int EnumToWire(object value) + { + int result; + switch (this.GetTypeCode()) + { + case ProtoTypeCode.SByte: + result = (int)((sbyte)value); + break; + case ProtoTypeCode.Byte: + result = (int)((byte)value); + break; + case ProtoTypeCode.Int16: + result = (int)((short)value); + break; + case ProtoTypeCode.UInt16: + result = (int)((ushort)value); + break; + case ProtoTypeCode.Int32: + result = (int)value; + break; + case ProtoTypeCode.UInt32: + result = (int)((uint)value); + break; + case ProtoTypeCode.Int64: + result = (int)((long)value); + break; + case ProtoTypeCode.UInt64: + result = (int)((ulong)value); + break; + default: + throw new InvalidOperationException(); + } + return result; + } + + private object WireToEnum(int value) + { + object result; + switch (this.GetTypeCode()) + { + case ProtoTypeCode.SByte: + result = Enum.ToObject(this.enumType, (sbyte)value); + break; + case ProtoTypeCode.Byte: + result = Enum.ToObject(this.enumType, (byte)value); + break; + case ProtoTypeCode.Int16: + result = Enum.ToObject(this.enumType, (short)value); + break; + case ProtoTypeCode.UInt16: + result = Enum.ToObject(this.enumType, (ushort)value); + break; + case ProtoTypeCode.Int32: + result = Enum.ToObject(this.enumType, value); + break; + case ProtoTypeCode.UInt32: + result = Enum.ToObject(this.enumType, (uint)value); + break; + case ProtoTypeCode.Int64: + result = Enum.ToObject(this.enumType, (long)value); + break; + case ProtoTypeCode.UInt64: + result = Enum.ToObject(this.enumType, (ulong)((long)value)); + break; + default: + throw new InvalidOperationException(); + } + return result; + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + int num = source.ReadInt32(); + bool flag = this.map == null; + object result; + if (flag) + { + result = this.WireToEnum(num); + } + else + { + for (int i = 0; i < this.map.Length; i++) + { + bool flag2 = this.map[i].WireValue == num; + if (flag2) + { + return this.map[i].TypedValue; + } + } + XSingleton.singleton.AddWarningLog("Warning: No ", (this.ExpectedType == null) ? "" : this.ExpectedType.FullName, " enum is mapped to the wire-value ", num.ToString(), null, null); + result = this.WireToEnum(num); + } + return result; + } + + public void Write(object value, ProtoWriter dest) + { + bool flag = this.map == null; + if (flag) + { + ProtoWriter.WriteInt32(this.EnumToWire(value), dest); + } + else + { + for (int i = 0; i < this.map.Length; i++) + { + bool flag2 = object.Equals(this.map[i].TypedValue, value); + if (flag2) + { + ProtoWriter.WriteInt32(this.map[i].WireValue, dest); + return; + } + } + XSingleton.singleton.AddErrorLog("Warning: No wire-value is mapped to the enum ", (value == null) ? "" : (value.GetType().FullName + "." + value.ToString()), " at position ", (dest == null) ? "unknown" : ProtoWriter.GetPosition(dest).ToString(), null, null); + ProtoWriter.WriteInt32(this.EnumToWire(value), dest); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs.meta new file mode 100644 index 00000000..b7d8f3ff --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/EnumSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5f5b7489e6b0ddc4b93c4825e7a746fe +timeCreated: 1611403811 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs new file mode 100644 index 00000000..144ab3e7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs @@ -0,0 +1,67 @@ +using System; +using System.Reflection; + +namespace ProtoBuf.Serializers +{ + internal sealed class FieldDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.forType; + } + } + + public override bool RequiresOldValue + { + get + { + return true; + } + } + + public override bool ReturnsValue + { + get + { + return false; + } + } + + private readonly FieldInfo field; + + private readonly Type forType; + + public FieldDecorator(Type forType, FieldInfo field, IProtoSerializer tail) : base(tail) + { + Helpers.DebugAssert(forType != null); + Helpers.DebugAssert(field != null); + this.forType = forType; + this.field = field; + } + + public override void Write(object value, ProtoWriter dest) + { + Helpers.DebugAssert(value != null); + value = this.field.GetValue(value); + bool flag = value != null; + if (flag) + { + this.Tail.Write(value, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value != null); + object obj = this.Tail.Read(this.Tail.RequiresOldValue ? this.field.GetValue(value) : null, source); + bool flag = obj != null; + if (flag) + { + this.field.SetValue(value, obj); + } + return null; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs.meta new file mode 100644 index 00000000..b0e12b26 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/FieldDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 7652c542da7cdc84ea87f1238de8651a +timeCreated: 1611403949 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs new file mode 100644 index 00000000..f9edaec9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class GuidSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return GuidSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(Guid); + + public GuidSerializer(TypeModel model) + { + } + + public void Write(object value, ProtoWriter dest) + { + BclHelpers.WriteGuid((Guid)value, dest); + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return BclHelpers.ReadGuid(source); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs.meta new file mode 100644 index 00000000..7bdf5b62 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/GuidSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 1743c869ef5abe840a34aeb5767cd253 +timeCreated: 1611403292 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs new file mode 100644 index 00000000..401b758a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs @@ -0,0 +1,17 @@ +using System; + +namespace ProtoBuf.Serializers +{ + internal interface IProtoSerializer + { + Type ExpectedType { get; } + + bool RequiresOldValue { get; } + + bool ReturnsValue { get; } + + void Write(object value, ProtoWriter dest); + + object Read(object value, ProtoReader source); + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs.meta new file mode 100644 index 00000000..1fc41e76 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: afc4abbab9743b74480e53f6e061e1c4 +timeCreated: 1611404347 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs new file mode 100644 index 00000000..d45e8049 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs @@ -0,0 +1,16 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal interface IProtoTypeSerializer : IProtoSerializer + { + bool HasCallbacks(TypeModel.CallbackType callbackType); + + bool CanCreateInstance(); + + object CreateInstance(ProtoReader source); + + void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context); + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs.meta new file mode 100644 index 00000000..0f9231d0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/IProtoTypeSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 12c7d0a3501f09743a248ea724ff6427 +timeCreated: 1611403243 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs new file mode 100644 index 00000000..7105976b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs @@ -0,0 +1,9 @@ +using System; + +namespace ProtoBuf.Serializers +{ + internal interface ISerializerProxy + { + IProtoSerializer Serializer { get; } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs.meta new file mode 100644 index 00000000..86848b70 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ISerializerProxy.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 19beab5bc626c734aafa122334e6aee2 +timeCreated: 1611403304 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs new file mode 100644 index 00000000..8133228d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs @@ -0,0 +1,252 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class ImmutableCollectionDecorator : ListDecorator + { + protected override bool RequireAdd + { + get + { + return false; + } + } + + private readonly MethodInfo builderFactory; + + private readonly MethodInfo add; + + private readonly MethodInfo addRange; + + private readonly MethodInfo finish; + + private static Type ResolveIReadOnlyCollection(Type declaredType, Type t) + { + foreach (Type type in declaredType.GetInterfaces()) + { + bool flag = type.IsGenericType && type.Name.StartsWith("IReadOnlyCollection`"); + if (flag) + { + bool flag2 = t != null; + if (flag2) + { + Type[] genericArguments = type.GetGenericArguments(); + bool flag3 = genericArguments.Length != 1 && genericArguments[0] != t; + if (flag3) + { + goto IL_68; + } + } + return type; + } + IL_68:; + } + return null; + } + + internal static bool IdentifyImmutable(TypeModel model, Type declaredType, out MethodInfo builderFactory, out MethodInfo add, out MethodInfo addRange, out MethodInfo finish) + { + MethodInfo methodInfo; + finish = (methodInfo = null); + addRange = (methodInfo = methodInfo); + add = (methodInfo = methodInfo); + builderFactory = methodInfo; + bool flag = model == null || declaredType == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !declaredType.IsGenericType; + if (flag2) + { + result = false; + } + else + { + Type[] genericArguments = declaredType.GetGenericArguments(); + int num = genericArguments.Length; + Type[] array; + if (num != 1) + { + if (num != 2) + { + return false; + } + Type type = model.MapType(typeof(KeyValuePair<, >)); + bool flag3 = type == null; + if (flag3) + { + return false; + } + type = type.MakeGenericType(genericArguments); + array = new Type[] + { + type + }; + } + else + { + array = genericArguments; + } + bool flag4 = ImmutableCollectionDecorator.ResolveIReadOnlyCollection(declaredType, null) == null; + if (flag4) + { + result = false; + } + else + { + string text = declaredType.Name; + int num2 = text.IndexOf('`'); + bool flag5 = num2 <= 0; + if (flag5) + { + result = false; + } + else + { + text = (declaredType.IsInterface ? text.Substring(1, num2 - 1) : text.Substring(0, num2)); + Type type2 = model.GetType(declaredType.Namespace + "." + text, declaredType.Assembly); + bool flag6 = type2 == null && text == "ImmutableSet"; + if (flag6) + { + type2 = model.GetType(declaredType.Namespace + ".ImmutableHashSet", declaredType.Assembly); + } + bool flag7 = type2 == null; + if (flag7) + { + result = false; + } + else + { + foreach (MethodInfo methodInfo2 in type2.GetMethods()) + { + bool flag8 = !methodInfo2.IsStatic || methodInfo2.Name != "CreateBuilder" || !methodInfo2.IsGenericMethodDefinition || methodInfo2.GetParameters().Length != 0 || methodInfo2.GetGenericArguments().Length != genericArguments.Length; + if (!flag8) + { + builderFactory = methodInfo2.MakeGenericMethod(genericArguments); + break; + } + } + Type type3 = model.MapType(typeof(void)); + bool flag9 = builderFactory == null || builderFactory.ReturnType == null || builderFactory.ReturnType == type3; + if (flag9) + { + result = false; + } + else + { + add = Helpers.GetInstanceMethod(builderFactory.ReturnType, "Add", array); + bool flag10 = add == null; + if (flag10) + { + result = false; + } + else + { + finish = Helpers.GetInstanceMethod(builderFactory.ReturnType, "ToImmutable", Helpers.EmptyTypes); + bool flag11 = finish == null || finish.ReturnType == null || finish.ReturnType == type3; + if (flag11) + { + result = false; + } + else + { + bool flag12 = finish.ReturnType != declaredType && !Helpers.IsAssignableFrom(declaredType, finish.ReturnType); + if (flag12) + { + result = false; + } + else + { + addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] + { + declaredType + }); + bool flag13 = addRange == null; + if (flag13) + { + Type type4 = model.MapType(typeof(IEnumerable<>), false); + bool flag14 = type4 != null; + if (flag14) + { + addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] + { + type4.MakeGenericType(array) + }); + } + } + result = true; + } + } + } + } + } + } + } + } + } + return result; + } + + internal ImmutableCollectionDecorator(TypeModel model, Type declaredType, Type concreteType, IProtoSerializer tail, int fieldNumber, bool writePacked, WireType packedWireType, bool returnList, bool overwriteList, bool supportNull, MethodInfo builderFactory, MethodInfo add, MethodInfo addRange, MethodInfo finish) : base(model, declaredType, concreteType, tail, fieldNumber, writePacked, packedWireType, returnList, overwriteList, supportNull) + { + this.builderFactory = builderFactory; + this.add = add; + this.addRange = addRange; + this.finish = finish; + } + + public override object Read(object value, ProtoReader source) + { + object obj = this.builderFactory.Invoke(null, null); + int fieldNumber = source.FieldNumber; + object[] s_argsRead = ProtoDecoratorBase.s_argsRead; + bool flag = base.AppendToCollection && value != null && ((IList)value).Count != 0; + if (flag) + { + bool flag2 = this.addRange != null; + if (flag2) + { + s_argsRead[0] = value; + this.addRange.Invoke(obj, s_argsRead); + } + else + { + foreach (object obj2 in ((IList)value)) + { + s_argsRead[0] = obj2; + this.add.Invoke(obj, s_argsRead); + } + } + } + bool flag3 = this.packedWireType != WireType.None && source.WireType == WireType.String; + if (flag3) + { + SubItemToken token = ProtoReader.StartSubItem(source); + while (ProtoReader.HasSubValue(this.packedWireType, source)) + { + s_argsRead[0] = this.Tail.Read(null, source); + this.add.Invoke(obj, s_argsRead); + } + ProtoReader.EndSubItem(token, source); + } + else + { + do + { + s_argsRead[0] = this.Tail.Read(null, source); + this.add.Invoke(obj, s_argsRead); + } + while (source.TryReadFieldHeader(fieldNumber)); + } + return this.finish.Invoke(obj, null); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs.meta new file mode 100644 index 00000000..8ffa65f1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ImmutableCollectionDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 995822048d3cf254a8a90d30634d77bd +timeCreated: 1611404195 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs new file mode 100644 index 00000000..e50ab1a5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class Int16Serializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return Int16Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(short); + + public Int16Serializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadInt16(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteInt16((short)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs.meta new file mode 100644 index 00000000..d67d3dbc --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int16Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: a35395277c429fe4e81a544136a3b71f +timeCreated: 1611404260 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs new file mode 100644 index 00000000..29c21112 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class Int32Serializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return Int32Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(int); + + public Int32Serializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadInt32(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteInt32((int)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs.meta new file mode 100644 index 00000000..c765da66 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int32Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 02408c964247cdc48af98e06a8bc7fbd +timeCreated: 1611402956 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs new file mode 100644 index 00000000..857ac8f7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class Int64Serializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return Int64Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(long); + + public Int64Serializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadInt64(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteInt64((long)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs.meta new file mode 100644 index 00000000..a75538f7 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/Int64Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: b883828ac17beb84db2bbd7bc703d530 +timeCreated: 1611404405 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs new file mode 100644 index 00000000..2c03de30 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs @@ -0,0 +1,365 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal class ListDecorator : ProtoDecoratorBase + { + private bool IsList + { + get + { + return (this.options & 1) > 0; + } + } + + private bool SuppressIList + { + get + { + return (this.options & 2) > 0; + } + } + + private bool WritePacked + { + get + { + return (this.options & 4) > 0; + } + } + + private bool SupportNull + { + get + { + return (this.options & 32) > 0; + } + } + + private bool ReturnList + { + get + { + return (this.options & 8) > 0; + } + } + + protected virtual bool RequireAdd + { + get + { + return true; + } + } + + public override Type ExpectedType + { + get + { + return this.declaredType; + } + } + + public override bool RequiresOldValue + { + get + { + return this.AppendToCollection; + } + } + + public override bool ReturnsValue + { + get + { + return this.ReturnList; + } + } + + protected bool AppendToCollection + { + get + { + return (this.options & 16) == 0; + } + } + + private readonly byte options; + + private const byte OPTIONS_IsList = 1; + + private const byte OPTIONS_SuppressIList = 2; + + private const byte OPTIONS_WritePacked = 4; + + private const byte OPTIONS_ReturnList = 8; + + private const byte OPTIONS_OverwriteList = 16; + + private const byte OPTIONS_SupportNull = 32; + + private readonly Type declaredType; + + private readonly Type concreteType; + + private readonly MethodInfo add; + + private readonly int fieldNumber; + + protected readonly WireType packedWireType; + + private static readonly Type ienumeratorType = typeof(IEnumerator); + + private static readonly Type ienumerableType = typeof(IEnumerable); + + internal static bool CanPack(WireType wireType) + { + return wireType <= WireType.Fixed64 || wireType == WireType.Fixed32 || wireType == WireType.SignedVariant; + } + + internal static ListDecorator Create(TypeModel model, Type declaredType, Type concreteType, IProtoSerializer tail, int fieldNumber, bool writePacked, WireType packedWireType, bool returnList, bool overwriteList, bool supportNull) + { + MethodInfo builderFactory = null; + MethodInfo methodInfo = null; + MethodInfo addRange = null; + MethodInfo finish = null; + bool flag = returnList && ImmutableCollectionDecorator.IdentifyImmutable(model, declaredType, out builderFactory, out methodInfo, out addRange, out finish); + ListDecorator result; + if (flag) + { + result = new ImmutableCollectionDecorator(model, declaredType, concreteType, tail, fieldNumber, writePacked, packedWireType, returnList, overwriteList, supportNull, builderFactory, methodInfo, addRange, finish); + } + else + { + result = new ListDecorator(model, declaredType, concreteType, tail, fieldNumber, writePacked, packedWireType, returnList, overwriteList, supportNull); + } + return result; + } + + protected ListDecorator(TypeModel model, Type declaredType, Type concreteType, IProtoSerializer tail, int fieldNumber, bool writePacked, WireType packedWireType, bool returnList, bool overwriteList, bool supportNull) : base(tail) + { + if (returnList) + { + this.options |= 8; + } + if (overwriteList) + { + this.options |= 16; + } + if (supportNull) + { + this.options |= 32; + } + bool flag = (writePacked || packedWireType != WireType.None) && fieldNumber <= 0; + if (flag) + { + throw new ArgumentOutOfRangeException("fieldNumber"); + } + bool flag2 = !ListDecorator.CanPack(packedWireType); + if (flag2) + { + if (writePacked) + { + throw new InvalidOperationException("Only simple data-types can use packed encoding"); + } + packedWireType = WireType.None; + } + this.fieldNumber = fieldNumber; + if (writePacked) + { + this.options |= 4; + } + this.packedWireType = packedWireType; + bool flag3 = declaredType == null; + if (flag3) + { + throw new ArgumentNullException("declaredType"); + } + bool isArray = declaredType.IsArray; + if (isArray) + { + throw new ArgumentException("Cannot treat arrays as lists", "declaredType"); + } + this.declaredType = declaredType; + this.concreteType = concreteType; + bool requireAdd = this.RequireAdd; + if (requireAdd) + { + bool flag4; + this.add = TypeModel.ResolveListAdd(model, declaredType, tail.ExpectedType, out flag4); + bool flag5 = flag4; + if (flag5) + { + this.options |= 1; + string fullName = declaredType.FullName; + bool flag6 = fullName != null && fullName.StartsWith("System.Data.Linq.EntitySet`1[["); + if (flag6) + { + this.options |= 2; + } + } + bool flag7 = this.add == null; + if (flag7) + { + throw new InvalidOperationException("Unable to resolve a suitable Add method for " + declaredType.FullName); + } + } + } + + protected MethodInfo GetEnumeratorInfo(TypeModel model, out MethodInfo moveNext, out MethodInfo current) + { + Type type = null; + Type expectedType = this.ExpectedType; + MethodInfo instanceMethod = Helpers.GetInstanceMethod(expectedType, "GetEnumerator", null); + Type expectedType2 = this.Tail.ExpectedType; + bool flag = instanceMethod != null; + if (flag) + { + Type returnType = instanceMethod.ReturnType; + Type type2 = returnType; + moveNext = Helpers.GetInstanceMethod(type2, "MoveNext", null); + PropertyInfo property = Helpers.GetProperty(type2, "Current", false); + current = ((property == null) ? null : Helpers.GetGetMethod(property, false, false)); + bool flag2 = moveNext == null && model.MapType(ListDecorator.ienumeratorType).IsAssignableFrom(type2); + if (flag2) + { + moveNext = Helpers.GetInstanceMethod(model.MapType(ListDecorator.ienumeratorType), "MoveNext", null); + } + bool flag3 = moveNext != null && moveNext.ReturnType == model.MapType(typeof(bool)) && current != null && current.ReturnType == expectedType2; + if (flag3) + { + return instanceMethod; + } + MethodInfo methodInfo; + current = (methodInfo = null); + moveNext = methodInfo; + } + Type type3 = model.MapType(typeof(IEnumerable<>), false); + bool flag4 = type3 != null; + if (flag4) + { + type3 = type3.MakeGenericType(new Type[] + { + expectedType2 + }); + type = type3; + } + bool flag5 = type != null && type.IsAssignableFrom(expectedType); + MethodInfo result; + if (flag5) + { + instanceMethod = Helpers.GetInstanceMethod(type, "GetEnumerator"); + Type returnType = instanceMethod.ReturnType; + Type type2 = returnType; + moveNext = Helpers.GetInstanceMethod(model.MapType(ListDecorator.ienumeratorType), "MoveNext"); + current = Helpers.GetGetMethod(Helpers.GetProperty(type2, "Current", false), false, false); + result = instanceMethod; + } + else + { + type = model.MapType(ListDecorator.ienumerableType); + instanceMethod = Helpers.GetInstanceMethod(type, "GetEnumerator"); + Type returnType = instanceMethod.ReturnType; + Type type2 = returnType; + moveNext = Helpers.GetInstanceMethod(type2, "MoveNext"); + current = Helpers.GetGetMethod(Helpers.GetProperty(type2, "Current", false), false, false); + result = instanceMethod; + } + return result; + } + + public override void Write(object value, ProtoWriter dest) + { + bool writePacked = this.WritePacked; + bool flag = writePacked; + SubItemToken token; + if (flag) + { + ProtoWriter.WriteFieldHeader(this.fieldNumber, WireType.String, dest); + token = ProtoWriter.StartSubItem(value, dest); + ProtoWriter.SetPackedField(this.fieldNumber, dest); + } + else + { + token = default(SubItemToken); + } + bool flag2 = !this.SupportNull; + foreach (object obj in ((IEnumerable)value)) + { + bool flag3 = flag2 && obj == null; + if (flag3) + { + throw new NullReferenceException(); + } + this.Tail.Write(obj, dest); + } + bool flag4 = writePacked; + if (flag4) + { + ProtoWriter.EndSubItem(token, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + int field = source.FieldNumber; + object obj = value; + bool flag = value == null; + if (flag) + { + value = Activator.CreateInstance(this.concreteType); + } + bool flag2 = this.IsList && !this.SuppressIList; + bool flag3 = this.packedWireType != WireType.None && source.WireType == WireType.String; + if (flag3) + { + SubItemToken token = ProtoReader.StartSubItem(source); + bool flag4 = flag2; + if (flag4) + { + IList list = (IList)value; + while (ProtoReader.HasSubValue(this.packedWireType, source)) + { + list.Add(this.Tail.Read(null, source)); + } + } + else + { + while (ProtoReader.HasSubValue(this.packedWireType, source)) + { + ProtoDecoratorBase.s_argsRead[0] = this.Tail.Read(null, source); + this.add.Invoke(value, ProtoDecoratorBase.s_argsRead); + } + } + ProtoReader.EndSubItem(token, source); + } + else + { + bool flag5 = flag2; + if (flag5) + { + IList list2 = (IList)value; + do + { + list2.Add(this.Tail.Read(null, source)); + } + while (source.TryReadFieldHeader(field)); + } + else + { + do + { + ProtoDecoratorBase.s_argsRead[0] = this.Tail.Read(null, source); + this.add.Invoke(value, ProtoDecoratorBase.s_argsRead); + } + while (source.TryReadFieldHeader(field)); + } + } + return (obj == value) ? null : value; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs.meta new file mode 100644 index 00000000..3c06cf2d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ListDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: fefcfc6e8a6b98341bf92b7df50d27d2 +timeCreated: 1611404944 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs new file mode 100644 index 00000000..95683855 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs @@ -0,0 +1,68 @@ +using System; +using System.Reflection; + +namespace ProtoBuf.Serializers +{ + internal sealed class MemberSpecifiedDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.Tail.ExpectedType; + } + } + + public override bool RequiresOldValue + { + get + { + return this.Tail.RequiresOldValue; + } + } + + public override bool ReturnsValue + { + get + { + return this.Tail.ReturnsValue; + } + } + + private readonly MethodInfo getSpecified; + + private readonly MethodInfo setSpecified; + + public MemberSpecifiedDecorator(MethodInfo getSpecified, MethodInfo setSpecified, IProtoSerializer tail) : base(tail) + { + bool flag = getSpecified == null && setSpecified == null; + if (flag) + { + throw new InvalidOperationException(); + } + this.getSpecified = getSpecified; + this.setSpecified = setSpecified; + } + + public override void Write(object value, ProtoWriter dest) + { + bool flag = this.getSpecified == null || (bool)this.getSpecified.Invoke(value, null); + if (flag) + { + this.Tail.Write(value, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + object result = this.Tail.Read(value, source); + ProtoDecoratorBase.s_argsRead[0] = true; + bool flag = this.setSpecified != null; + if (flag) + { + this.setSpecified.Invoke(value, ProtoDecoratorBase.s_argsRead); + } + return result; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs.meta new file mode 100644 index 00000000..793dcf44 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/MemberSpecifiedDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 739518db68917a34e836154cb2eaf459 +timeCreated: 1611403941 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs new file mode 100644 index 00000000..6dd8be72 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs @@ -0,0 +1,56 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class NetObjectSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return this.type; + } + } + + public bool ReturnsValue + { + get + { + return true; + } + } + + public bool RequiresOldValue + { + get + { + return true; + } + } + + private readonly int key; + + private readonly Type type; + + private readonly BclHelpers.NetObjectOptions options; + + public NetObjectSerializer(TypeModel model, Type type, int key, BclHelpers.NetObjectOptions options) + { + bool flag = (options & BclHelpers.NetObjectOptions.DynamicType) > BclHelpers.NetObjectOptions.None; + this.key = (flag ? -1 : key); + this.type = (flag ? model.MapType(typeof(object)) : type); + this.options = options; + } + + public object Read(object value, ProtoReader source) + { + return BclHelpers.ReadNetObject(value, source, this.key, (this.type == typeof(object)) ? null : this.type, this.options); + } + + public void Write(object value, ProtoWriter dest) + { + BclHelpers.WriteNetObject(value, dest, this.key, this.options); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs.meta new file mode 100644 index 00000000..1ab011bb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NetObjectSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: a98a338097dc0e846bbe30b6f334caf6 +timeCreated: 1611404299 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs new file mode 100644 index 00000000..2285d847 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs @@ -0,0 +1,89 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class NullDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.expectedType; + } + } + + public override bool ReturnsValue + { + get + { + return true; + } + } + + public override bool RequiresOldValue + { + get + { + return true; + } + } + + private readonly Type expectedType; + + public const int Tag = 1; + + public NullDecorator(TypeModel model, IProtoSerializer tail) : base(tail) + { + bool flag = !tail.ReturnsValue; + if (flag) + { + throw new NotSupportedException("NullDecorator only supports implementations that return values"); + } + Type type = tail.ExpectedType; + bool flag2 = Helpers.IsValueType(type); + if (flag2) + { + this.expectedType = model.MapType(typeof(Nullable<>)).MakeGenericType(new Type[] + { + type + }); + } + else + { + this.expectedType = type; + } + } + + public override object Read(object value, ProtoReader source) + { + SubItemToken token = ProtoReader.StartSubItem(source); + int num; + while ((num = source.ReadFieldHeader()) > 0) + { + bool flag = num == 1; + if (flag) + { + value = this.Tail.Read(value, source); + } + else + { + source.SkipField(); + } + } + ProtoReader.EndSubItem(token, source); + return value; + } + + public override void Write(object value, ProtoWriter dest) + { + SubItemToken token = ProtoWriter.StartSubItem(null, dest); + bool flag = value != null; + if (flag) + { + this.Tail.Write(value, dest); + } + ProtoWriter.EndSubItem(token, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs.meta new file mode 100644 index 00000000..fb5b1c05 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/NullDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 05d6503399b3fa748a1d9a82686028a3 +timeCreated: 1611402964 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs new file mode 100644 index 00000000..8cc1b68d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs @@ -0,0 +1,91 @@ +using System; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class ParseableSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return this.parse.DeclaringType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private readonly MethodInfo parse; + + public static ParseableSerializer TryCreate(Type type, TypeModel model) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + MethodInfo method = type.GetMethod("Parse", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public, null, new Type[] + { + model.MapType(typeof(string)) + }, null); + bool flag2 = method != null && method.ReturnType == type; + ParseableSerializer result; + if (flag2) + { + bool flag3 = Helpers.IsValueType(type); + if (flag3) + { + MethodInfo customToString = ParseableSerializer.GetCustomToString(type); + bool flag4 = customToString == null || customToString.ReturnType != model.MapType(typeof(string)); + if (flag4) + { + return null; + } + } + result = new ParseableSerializer(method); + } + else + { + result = null; + } + return result; + } + + private static MethodInfo GetCustomToString(Type type) + { + return type.GetMethod("ToString", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Helpers.EmptyTypes, null); + } + + private ParseableSerializer(MethodInfo parse) + { + this.parse = parse; + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + ProtoDecoratorBase.s_argsRead[0] = source.ReadString(); + return this.parse.Invoke(null, ProtoDecoratorBase.s_argsRead); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteString(value.ToString(), dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs.meta new file mode 100644 index 00000000..7b87947e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ParseableSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 833aecc4d9c5272499fdfa8e8acfca59 +timeCreated: 1611404043 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs new file mode 100644 index 00000000..4240d53d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs @@ -0,0 +1,143 @@ +using System; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class PropertyDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return this.forType; + } + } + + public override bool RequiresOldValue + { + get + { + return true; + } + } + + public override bool ReturnsValue + { + get + { + return false; + } + } + + private readonly PropertyInfo property; + + private readonly Type forType; + + private readonly bool readOptionsWriteValue; + + private readonly MethodInfo shadowSetter; + + public PropertyDecorator(TypeModel model, Type forType, PropertyInfo property, IProtoSerializer tail) : base(tail) + { + Helpers.DebugAssert(forType != null); + Helpers.DebugAssert(property != null); + this.forType = forType; + this.property = property; + PropertyDecorator.SanityCheck(model, property, tail, out this.readOptionsWriteValue, true, true); + this.shadowSetter = PropertyDecorator.GetShadowSetter(model, property); + } + + private static void SanityCheck(TypeModel model, PropertyInfo property, IProtoSerializer tail, out bool writeValue, bool nonPublic, bool allowInternal) + { + bool flag = property == null; + if (flag) + { + throw new ArgumentNullException("property"); + } + writeValue = (tail.ReturnsValue && (PropertyDecorator.GetShadowSetter(model, property) != null || (property.CanWrite && Helpers.GetSetMethod(property, nonPublic, allowInternal) != null))); + bool flag2 = !property.CanRead || Helpers.GetGetMethod(property, nonPublic, allowInternal) == null; + if (flag2) + { + throw new InvalidOperationException("Cannot serialize property without a get accessor"); + } + bool flag3 = !writeValue && (!tail.RequiresOldValue || Helpers.IsValueType(tail.ExpectedType)); + if (flag3) + { + throw new InvalidOperationException("Cannot apply changes to property " + property.DeclaringType.FullName + "." + property.Name); + } + } + + private static MethodInfo GetShadowSetter(TypeModel model, PropertyInfo property) + { + Type reflectedType = property.ReflectedType; + ProtoDecoratorBase.s_propertyType[0] = property.PropertyType; + MethodInfo instanceMethod = Helpers.GetInstanceMethod(reflectedType, "Set" + property.Name, ProtoDecoratorBase.s_propertyType); + bool flag = instanceMethod == null || !instanceMethod.IsPublic || instanceMethod.ReturnType != model.MapType(typeof(void)); + MethodInfo result; + if (flag) + { + result = null; + } + else + { + result = instanceMethod; + } + return result; + } + + public override void Write(object value, ProtoWriter dest) + { + Helpers.DebugAssert(value != null); + value = this.property.GetValue(value, null); + bool flag = value != null; + if (flag) + { + this.Tail.Write(value, dest); + } + } + + public override object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value != null); + object value2 = this.Tail.RequiresOldValue ? this.property.GetValue(value, null) : null; + object obj = this.Tail.Read(value2, source); + bool flag = this.readOptionsWriteValue && obj != null; + if (flag) + { + bool flag2 = this.shadowSetter == null; + if (flag2) + { + this.property.SetValue(value, obj, null); + } + else + { + ProtoDecoratorBase.s_argsRead[0] = obj; + this.shadowSetter.Invoke(value, ProtoDecoratorBase.s_argsRead); + } + } + return null; + } + + internal static bool CanWrite(TypeModel model, MemberInfo member) + { + bool flag = member == null; + if (flag) + { + throw new ArgumentNullException("member"); + } + PropertyInfo propertyInfo = member as PropertyInfo; + bool flag2 = propertyInfo != null; + bool result; + if (flag2) + { + result = (propertyInfo.CanWrite || PropertyDecorator.GetShadowSetter(model, propertyInfo) != null); + } + else + { + result = (member is FieldInfo); + } + return result; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs.meta new file mode 100644 index 00000000..edd7c89e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/PropertyDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f0600dad016715249ba5a8362c4e93b4 +timeCreated: 1611404831 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs new file mode 100644 index 00000000..e8195611 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs @@ -0,0 +1,30 @@ +using System; + +namespace ProtoBuf.Serializers +{ + internal abstract class ProtoDecoratorBase : IProtoSerializer + { + public abstract Type ExpectedType { get; } + + public abstract bool ReturnsValue { get; } + + public abstract bool RequiresOldValue { get; } + + protected readonly IProtoSerializer Tail; + + public static Type[] s_propertyType = new Type[1]; + + public static object[] s_argsRead = new object[1]; + + public static object[] s_argsWrite = new object[1]; + + protected ProtoDecoratorBase(IProtoSerializer tail) + { + this.Tail = tail; + } + + public abstract void Write(object value, ProtoWriter dest); + + public abstract object Read(object value, ProtoReader source); + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs.meta new file mode 100644 index 00000000..0783e64b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/ProtoDecoratorBase.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 7f721c5867de15248b13f8d3c9abb615 +timeCreated: 1611404030 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs new file mode 100644 index 00000000..04880c52 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class SByteSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return SByteSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(sbyte); + + public SByteSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadSByte(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteSByte((sbyte)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs.meta new file mode 100644 index 00000000..bb30cebe --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SByteSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c62250c7286c2d045814ce99fe761bee +timeCreated: 1611404508 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs new file mode 100644 index 00000000..1b49bf8a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class SingleSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return SingleSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(float); + + public SingleSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadSingle(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteSingle((float)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs.meta new file mode 100644 index 00000000..2b9bcd3b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SingleSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: a4fcc9e482669344f8ff53d32f94f2f5 +timeCreated: 1611404284 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs new file mode 100644 index 00000000..09827b2a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class StringSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return StringSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(string); + + public StringSerializer(TypeModel model) + { + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteString((string)value, dest); + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadString(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs.meta new file mode 100644 index 00000000..b34fb67c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/StringSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4349e44ff56a8094abcba104a2ebe4f1 +timeCreated: 1611403641 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs new file mode 100644 index 00000000..b2358d17 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs @@ -0,0 +1,96 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class SubItemSerializer : IProtoTypeSerializer, IProtoSerializer + { + Type IProtoSerializer.ExpectedType + { + get + { + return this.type; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return true; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private readonly int key; + + private readonly Type type; + + private readonly ISerializerProxy proxy; + + private readonly bool recursionCheck; + + bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType) + { + return ((IProtoTypeSerializer)this.proxy.Serializer).HasCallbacks(callbackType); + } + + bool IProtoTypeSerializer.CanCreateInstance() + { + return ((IProtoTypeSerializer)this.proxy.Serializer).CanCreateInstance(); + } + + void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) + { + ((IProtoTypeSerializer)this.proxy.Serializer).Callback(value, callbackType, context); + } + + object IProtoTypeSerializer.CreateInstance(ProtoReader source) + { + return ((IProtoTypeSerializer)this.proxy.Serializer).CreateInstance(source); + } + + public SubItemSerializer(Type type, int key, ISerializerProxy proxy, bool recursionCheck) + { + bool flag = type == null; + if (flag) + { + throw new ArgumentNullException("type"); + } + bool flag2 = proxy == null; + if (flag2) + { + throw new ArgumentNullException("proxy"); + } + this.type = type; + this.proxy = proxy; + this.key = key; + this.recursionCheck = recursionCheck; + } + + void IProtoSerializer.Write(object value, ProtoWriter dest) + { + bool flag = this.recursionCheck; + if (flag) + { + ProtoWriter.WriteObject(value, this.key, dest); + } + else + { + ProtoWriter.WriteRecursionSafeObject(value, this.key, dest); + } + } + + object IProtoSerializer.Read(object value, ProtoReader source) + { + return ProtoReader.ReadObject(value, this.key, source); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs.meta new file mode 100644 index 00000000..f2088d37 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SubItemSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: af8ec618884c3e846a0aa0126f79685d +timeCreated: 1611404345 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs new file mode 100644 index 00000000..d7f171a5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs @@ -0,0 +1,154 @@ +using System; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class SurrogateSerializer : IProtoTypeSerializer, IProtoSerializer + { + public bool ReturnsValue + { + get + { + return false; + } + } + + public bool RequiresOldValue + { + get + { + return true; + } + } + + public Type ExpectedType + { + get + { + return this.forType; + } + } + + private readonly Type forType; + + private readonly Type declaredType; + + private readonly MethodInfo toTail; + + private readonly MethodInfo fromTail; + + private IProtoTypeSerializer rootTail; + + bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType) + { + return false; + } + + bool IProtoTypeSerializer.CanCreateInstance() + { + return false; + } + + object IProtoTypeSerializer.CreateInstance(ProtoReader source) + { + throw new NotSupportedException(); + } + + void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) + { + } + + public SurrogateSerializer(TypeModel model, Type forType, Type declaredType, IProtoTypeSerializer rootTail) + { + Helpers.DebugAssert(forType != null, "forType"); + Helpers.DebugAssert(declaredType != null, "declaredType"); + Helpers.DebugAssert(rootTail != null, "rootTail"); + Helpers.DebugAssert(rootTail.RequiresOldValue, "RequiresOldValue"); + Helpers.DebugAssert(!rootTail.ReturnsValue, "ReturnsValue"); + Helpers.DebugAssert(declaredType == rootTail.ExpectedType || Helpers.IsSubclassOf(declaredType, rootTail.ExpectedType)); + this.forType = forType; + this.declaredType = declaredType; + this.rootTail = rootTail; + this.toTail = this.GetConversion(model, true); + this.fromTail = this.GetConversion(model, false); + } + + private static bool HasCast(TypeModel model, Type type, Type from, Type to, out MethodInfo op) + { + MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + Type type2 = null; + foreach (MethodInfo methodInfo in methods) + { + bool flag = methodInfo.ReturnType != to; + if (!flag) + { + ParameterInfo[] parameters = methodInfo.GetParameters(); + bool flag2 = parameters.Length == 1 && parameters[0].ParameterType == from; + if (flag2) + { + bool flag3 = type2 == null; + if (flag3) + { + type2 = model.MapType(typeof(ProtoConverterAttribute), false); + bool flag4 = type2 == null; + if (flag4) + { + break; + } + } + bool flag5 = methodInfo.IsDefined(type2, true); + if (flag5) + { + op = methodInfo; + return true; + } + } + } + } + foreach (MethodInfo methodInfo2 in methods) + { + bool flag6 = (methodInfo2.Name != "op_Implicit" && methodInfo2.Name != "op_Explicit") || methodInfo2.ReturnType != to; + if (!flag6) + { + ParameterInfo[] parameters = methodInfo2.GetParameters(); + bool flag7 = parameters.Length == 1 && parameters[0].ParameterType == from; + if (flag7) + { + op = methodInfo2; + return true; + } + } + } + op = null; + return false; + } + + public MethodInfo GetConversion(TypeModel model, bool toTail) + { + Type to = toTail ? this.declaredType : this.forType; + Type from = toTail ? this.forType : this.declaredType; + MethodInfo result; + bool flag = SurrogateSerializer.HasCast(model, this.declaredType, from, to, out result) || SurrogateSerializer.HasCast(model, this.forType, from, to, out result); + if (flag) + { + return result; + } + throw new InvalidOperationException("No suitable conversion operator found for surrogate: " + this.forType.FullName + " / " + this.declaredType.FullName); + } + + public void Write(object value, ProtoWriter writer) + { + ProtoDecoratorBase.s_argsWrite[0] = value; + this.rootTail.Write(this.toTail.Invoke(null, ProtoDecoratorBase.s_argsWrite), writer); + } + + public object Read(object value, ProtoReader source) + { + ProtoDecoratorBase.s_argsRead[0] = value; + value = this.toTail.Invoke(null, ProtoDecoratorBase.s_argsRead); + ProtoDecoratorBase.s_argsRead[0] = this.rootTail.Read(value, source); + return this.fromTail.Invoke(null, ProtoDecoratorBase.s_argsRead); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs.meta new file mode 100644 index 00000000..eb6eeaac --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SurrogateSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4320ebf7d1587cb41a71815ac5e941a8 +timeCreated: 1611403641 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs new file mode 100644 index 00000000..1cc322d4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class SystemTypeSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return SystemTypeSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(Type); + + public SystemTypeSerializer(TypeModel model) + { + } + + void IProtoSerializer.Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteType((Type)value, dest); + } + + object IProtoSerializer.Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadType(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs.meta new file mode 100644 index 00000000..fd810f93 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/SystemTypeSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 316b036e681598744a7a6aa9fa12a8fc +timeCreated: 1611403545 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs new file mode 100644 index 00000000..7a0e390f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs @@ -0,0 +1,105 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class TagDecorator : ProtoDecoratorBase, IProtoTypeSerializer, IProtoSerializer + { + public override Type ExpectedType + { + get + { + return this.Tail.ExpectedType; + } + } + + public override bool RequiresOldValue + { + get + { + return this.Tail.RequiresOldValue; + } + } + + public override bool ReturnsValue + { + get + { + return this.Tail.ReturnsValue; + } + } + + private bool NeedsHint + { + get + { + return (this.wireType & (WireType)(-8)) > WireType.Variant; + } + } + + private readonly bool strict; + + private readonly int fieldNumber; + + private readonly WireType wireType; + + public bool HasCallbacks(TypeModel.CallbackType callbackType) + { + IProtoTypeSerializer protoTypeSerializer = this.Tail as IProtoTypeSerializer; + return protoTypeSerializer != null && protoTypeSerializer.HasCallbacks(callbackType); + } + + public bool CanCreateInstance() + { + IProtoTypeSerializer protoTypeSerializer = this.Tail as IProtoTypeSerializer; + return protoTypeSerializer != null && protoTypeSerializer.CanCreateInstance(); + } + + public object CreateInstance(ProtoReader source) + { + return ((IProtoTypeSerializer)this.Tail).CreateInstance(source); + } + + public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) + { + IProtoTypeSerializer protoTypeSerializer = this.Tail as IProtoTypeSerializer; + bool flag = protoTypeSerializer != null; + if (flag) + { + protoTypeSerializer.Callback(value, callbackType, context); + } + } + + public TagDecorator(int fieldNumber, WireType wireType, bool strict, IProtoSerializer tail) : base(tail) + { + this.fieldNumber = fieldNumber; + this.wireType = wireType; + this.strict = strict; + } + + public override object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(this.fieldNumber == source.FieldNumber); + bool flag = this.strict; + if (flag) + { + source.Assert(this.wireType); + } + else + { + bool needsHint = this.NeedsHint; + if (needsHint) + { + source.Hint(this.wireType); + } + } + return this.Tail.Read(value, source); + } + + public override void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteFieldHeader(this.fieldNumber, this.wireType, dest); + this.Tail.Write(value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs.meta new file mode 100644 index 00000000..47c539c0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TagDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f5c00b69b85f4714b903019fd5c6d4ec +timeCreated: 1611404877 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs new file mode 100644 index 00000000..650a2fa8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class TimeSpanSerializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return TimeSpanSerializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(TimeSpan); + + public TimeSpanSerializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return BclHelpers.ReadTimeSpan(source); + } + + public void Write(object value, ProtoWriter dest) + { + BclHelpers.WriteTimeSpan((TimeSpan)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs.meta new file mode 100644 index 00000000..e9a11954 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TimeSpanSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 8274313ccbb1a974b835114e01a78f04 +timeCreated: 1611404040 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs new file mode 100644 index 00000000..49424ffb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs @@ -0,0 +1,211 @@ +using System; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class TupleSerializer : IProtoTypeSerializer, IProtoSerializer + { + public Type ExpectedType + { + get + { + return this.ctor.DeclaringType; + } + } + + public bool RequiresOldValue + { + get + { + return true; + } + } + + public bool ReturnsValue + { + get + { + return false; + } + } + + private readonly MemberInfo[] members; + + private readonly ConstructorInfo ctor; + + private IProtoSerializer[] tails; + + public TupleSerializer(RuntimeTypeModel model, ConstructorInfo ctor, MemberInfo[] members) + { + bool flag = ctor == null; + if (flag) + { + throw new ArgumentNullException("ctor"); + } + bool flag2 = members == null; + if (flag2) + { + throw new ArgumentNullException("members"); + } + this.ctor = ctor; + this.members = members; + this.tails = new IProtoSerializer[members.Length]; + ParameterInfo[] parameters = ctor.GetParameters(); + for (int i = 0; i < members.Length; i++) + { + Type parameterType = parameters[i].ParameterType; + Type type = null; + Type concreteType = null; + MetaType.ResolveListTypes(model, parameterType, ref type, ref concreteType); + Type type2 = (type == null) ? parameterType : type; + bool asReference = false; + int num = model.FindOrAddAuto(type2, false, true, false); + bool flag3 = num >= 0; + if (flag3) + { + asReference = model[type2].AsReferenceDefault; + } + WireType wireType; + IProtoSerializer protoSerializer = ValueMember.TryGetCoreSerializer(model, DataFormat.Default, type2, out wireType, asReference, false, false, true); + bool flag4 = protoSerializer == null; + if (flag4) + { + throw new InvalidOperationException("No serializer defined for type: " + type2.FullName); + } + protoSerializer = new TagDecorator(i + 1, wireType, false, protoSerializer); + bool flag5 = type == null; + IProtoSerializer protoSerializer2; + if (flag5) + { + protoSerializer2 = protoSerializer; + } + else + { + bool isArray = parameterType.IsArray; + if (isArray) + { + protoSerializer2 = new ArrayDecorator(model, protoSerializer, i + 1, false, wireType, parameterType, false, false); + } + else + { + protoSerializer2 = ListDecorator.Create(model, parameterType, concreteType, protoSerializer, i + 1, false, wireType, true, false, false); + } + } + this.tails[i] = protoSerializer2; + } + } + + public bool HasCallbacks(TypeModel.CallbackType callbackType) + { + return false; + } + + void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) + { + } + + object IProtoTypeSerializer.CreateInstance(ProtoReader source) + { + throw new NotSupportedException(); + } + + private object GetValue(object obj, int index) + { + PropertyInfo propertyInfo; + bool flag = (propertyInfo = (this.members[index] as PropertyInfo)) != null; + object result; + if (flag) + { + bool flag2 = obj == null; + if (flag2) + { + result = (Helpers.IsValueType(propertyInfo.PropertyType) ? Activator.CreateInstance(propertyInfo.PropertyType) : null); + } + else + { + result = propertyInfo.GetValue(obj, null); + } + } + else + { + FieldInfo fieldInfo; + bool flag3 = (fieldInfo = (this.members[index] as FieldInfo)) != null; + if (!flag3) + { + throw new InvalidOperationException(); + } + bool flag4 = obj == null; + if (flag4) + { + result = (Helpers.IsValueType(fieldInfo.FieldType) ? Activator.CreateInstance(fieldInfo.FieldType) : null); + } + else + { + result = fieldInfo.GetValue(obj); + } + } + return result; + } + + public object Read(object value, ProtoReader source) + { + object[] array = new object[this.members.Length]; + bool flag = false; + bool flag2 = value == null; + if (flag2) + { + flag = true; + } + for (int i = 0; i < array.Length; i++) + { + array[i] = this.GetValue(value, i); + } + int num; + while ((num = source.ReadFieldHeader()) > 0) + { + flag = true; + bool flag3 = num <= this.tails.Length; + if (flag3) + { + IProtoSerializer protoSerializer = this.tails[num - 1]; + array[num - 1] = this.tails[num - 1].Read(protoSerializer.RequiresOldValue ? array[num - 1] : null, source); + } + else + { + source.SkipField(); + } + } + return flag ? this.ctor.Invoke(array) : value; + } + + public void Write(object value, ProtoWriter dest) + { + for (int i = 0; i < this.tails.Length; i++) + { + object value2 = this.GetValue(value, i); + bool flag = value2 != null; + if (flag) + { + this.tails[i].Write(value2, dest); + } + } + } + + private Type GetMemberType(int index) + { + Type memberType = Helpers.GetMemberType(this.members[index]); + bool flag = memberType == null; + if (flag) + { + throw new InvalidOperationException(); + } + return memberType; + } + + bool IProtoTypeSerializer.CanCreateInstance() + { + return false; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs.meta new file mode 100644 index 00000000..864aa85d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TupleSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 824ff1f17fa0ade46834f8070e773b2b +timeCreated: 1611404039 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs new file mode 100644 index 00000000..fd8fe62c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs @@ -0,0 +1,445 @@ +using System; +using System.Reflection; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class TypeSerializer : IProtoTypeSerializer, IProtoSerializer + { + public Type ExpectedType + { + get + { + return this.forType; + } + } + + private bool CanHaveInheritance + { + get + { + return (this.forType.IsClass || this.forType.IsInterface) && !this.forType.IsSealed; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return true; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return false; + } + } + + private readonly Type forType; + + private readonly Type constructType; + + private readonly IProtoSerializer[] serializers; + + private readonly int[] fieldNumbers; + + private readonly bool isRootType; + + private readonly bool useConstructor; + + private readonly bool isExtensible; + + private readonly bool hasConstructor; + + private readonly CallbackSet callbacks; + + private readonly MethodInfo[] baseCtorCallbacks; + + private readonly MethodInfo factory; + + private static readonly Type iextensible = typeof(IExtensible); + + public bool HasCallbacks(TypeModel.CallbackType callbackType) + { + bool flag = this.callbacks != null && this.callbacks[callbackType] != null; + bool result; + if (flag) + { + result = true; + } + else + { + for (int i = 0; i < this.serializers.Length; i++) + { + bool flag2 = this.serializers[i].ExpectedType != this.forType && ((IProtoTypeSerializer)this.serializers[i]).HasCallbacks(callbackType); + if (flag2) + { + return true; + } + } + result = false; + } + return result; + } + + public TypeSerializer(TypeModel model, Type forType, int[] fieldNumbers, IProtoSerializer[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, CallbackSet callbacks, Type constructType, MethodInfo factory) + { + Helpers.DebugAssert(forType != null); + Helpers.DebugAssert(fieldNumbers != null); + Helpers.DebugAssert(serializers != null); + Helpers.DebugAssert(fieldNumbers.Length == serializers.Length); + Helpers.Sort(fieldNumbers, serializers); + bool flag = false; + for (int i = 1; i < fieldNumbers.Length; i++) + { + bool flag2 = fieldNumbers[i] == fieldNumbers[i - 1]; + if (flag2) + { + throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i].ToString() + " on: " + forType.FullName); + } + bool flag3 = !flag && serializers[i].ExpectedType != forType; + if (flag3) + { + flag = true; + } + } + this.forType = forType; + this.factory = factory; + bool flag4 = constructType == null; + if (flag4) + { + constructType = forType; + } + else + { + bool flag5 = !forType.IsAssignableFrom(constructType); + if (flag5) + { + throw new InvalidOperationException(forType.FullName + " cannot be assigned from " + constructType.FullName); + } + } + this.constructType = constructType; + this.serializers = serializers; + this.fieldNumbers = fieldNumbers; + this.callbacks = callbacks; + this.isRootType = isRootType; + this.useConstructor = useConstructor; + bool flag6 = baseCtorCallbacks != null && baseCtorCallbacks.Length == 0; + if (flag6) + { + baseCtorCallbacks = null; + } + this.baseCtorCallbacks = baseCtorCallbacks; + bool flag7 = Helpers.GetUnderlyingType(forType) != null; + if (flag7) + { + throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType"); + } + bool flag8 = model.MapType(TypeSerializer.iextensible).IsAssignableFrom(forType); + if (flag8) + { + bool flag9 = forType.IsValueType || !isRootType || flag; + if (flag9) + { + throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance"); + } + this.isExtensible = true; + } + this.hasConstructor = (!constructType.IsAbstract && Helpers.GetConstructor(constructType, Helpers.EmptyTypes, true) != null); + bool flag10 = constructType != forType && useConstructor && !this.hasConstructor; + if (flag10) + { + throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, "constructType"); + } + } + + bool IProtoTypeSerializer.CanCreateInstance() + { + return true; + } + + object IProtoTypeSerializer.CreateInstance(ProtoReader source) + { + return this.CreateInstance(source, false); + } + + public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) + { + bool flag = this.callbacks != null; + if (flag) + { + this.InvokeCallback(this.callbacks[callbackType], value, context); + } + IProtoTypeSerializer protoTypeSerializer = (IProtoTypeSerializer)this.GetMoreSpecificSerializer(value); + bool flag2 = protoTypeSerializer != null; + if (flag2) + { + protoTypeSerializer.Callback(value, callbackType, context); + } + } + + private IProtoSerializer GetMoreSpecificSerializer(object value) + { + bool flag = !this.CanHaveInheritance; + IProtoSerializer result; + if (flag) + { + result = null; + } + else + { + Type type = value.GetType(); + bool flag2 = type == this.forType; + if (flag2) + { + result = null; + } + else + { + for (int i = 0; i < this.serializers.Length; i++) + { + IProtoSerializer protoSerializer = this.serializers[i]; + bool flag3 = protoSerializer.ExpectedType != this.forType && Helpers.IsAssignableFrom(protoSerializer.ExpectedType, type); + if (flag3) + { + return protoSerializer; + } + } + bool flag4 = type == this.constructType; + if (flag4) + { + result = null; + } + else + { + TypeModel.ThrowUnexpectedSubtype(this.forType, type); + result = null; + } + } + } + return result; + } + + public void Write(object value, ProtoWriter dest) + { + bool flag = this.isRootType; + if (flag) + { + this.Callback(value, TypeModel.CallbackType.BeforeSerialize, dest.Context); + } + IProtoSerializer moreSpecificSerializer = this.GetMoreSpecificSerializer(value); + bool flag2 = moreSpecificSerializer != null; + if (flag2) + { + moreSpecificSerializer.Write(value, dest); + } + for (int i = 0; i < this.serializers.Length; i++) + { + IProtoSerializer protoSerializer = this.serializers[i]; + bool flag3 = protoSerializer.ExpectedType == this.forType; + if (flag3) + { + protoSerializer.Write(value, dest); + } + } + bool flag4 = this.isExtensible; + if (flag4) + { + ProtoWriter.AppendExtensionData((IExtensible)value, dest); + } + bool flag5 = this.isRootType; + if (flag5) + { + this.Callback(value, TypeModel.CallbackType.AfterSerialize, dest.Context); + } + } + + public object Read(object value, ProtoReader source) + { + bool flag = this.isRootType && value != null; + if (flag) + { + this.Callback(value, TypeModel.CallbackType.BeforeDeserialize, source.Context); + } + int num = 0; + int num2 = 0; + int num3; + while ((num3 = source.ReadFieldHeader()) > 0) + { + bool flag2 = false; + bool flag3 = num3 < num; + if (flag3) + { + num2 = (num = 0); + } + for (int i = num2; i < this.fieldNumbers.Length; i++) + { + bool flag4 = this.fieldNumbers[i] == num3; + if (flag4) + { + IProtoSerializer protoSerializer = this.serializers[i]; + Type expectedType = protoSerializer.ExpectedType; + bool flag5 = value == null; + if (flag5) + { + bool flag6 = expectedType == this.forType; + if (flag6) + { + value = this.CreateInstance(source, true); + } + } + else + { + bool flag7 = expectedType != this.forType && ((IProtoTypeSerializer)protoSerializer).CanCreateInstance() && expectedType.IsSubclassOf(value.GetType()); + if (flag7) + { + value = ProtoReader.Merge(source, value, ((IProtoTypeSerializer)protoSerializer).CreateInstance(source)); + } + } + bool returnsValue = protoSerializer.ReturnsValue; + if (returnsValue) + { + value = protoSerializer.Read(value, source); + } + else + { + protoSerializer.Read(value, source); + } + num2 = i; + num = num3; + flag2 = true; + break; + } + } + bool flag8 = !flag2; + if (flag8) + { + bool flag9 = value == null; + if (flag9) + { + value = this.CreateInstance(source, true); + } + bool flag10 = this.isExtensible; + if (flag10) + { + source.AppendExtensionData((IExtensible)value); + } + else + { + source.SkipField(); + } + } + } + bool flag11 = value == null; + if (flag11) + { + value = this.CreateInstance(source, true); + } + bool flag12 = this.isRootType; + if (flag12) + { + this.Callback(value, TypeModel.CallbackType.AfterDeserialize, source.Context); + } + return value; + } + + private object InvokeCallback(MethodInfo method, object obj, SerializationContext context) + { + object result = null; + bool flag = method != null; + if (flag) + { + ParameterInfo[] parameters = method.GetParameters(); + int num = parameters.Length; + object[] array; + bool flag2; + if (num != 0) + { + array = new object[parameters.Length]; + flag2 = true; + for (int i = 0; i < array.Length; i++) + { + Type parameterType = parameters[i].ParameterType; + bool flag3 = parameterType == typeof(SerializationContext); + object obj2; + if (flag3) + { + obj2 = context; + } + else + { + bool flag4 = parameterType == typeof(Type); + if (flag4) + { + obj2 = this.constructType; + } + else + { + obj2 = null; + flag2 = false; + } + } + array[i] = obj2; + } + } + else + { + array = null; + flag2 = true; + } + bool flag5 = flag2; + if (!flag5) + { + throw CallbackSet.CreateInvalidCallbackSignature(method); + } + result = method.Invoke(obj, array); + } + return result; + } + + private object CreateInstance(ProtoReader source, bool includeLocalCallback) + { + bool flag = this.factory != null; + object obj; + if (flag) + { + obj = this.InvokeCallback(this.factory, null, source.Context); + } + else + { + bool flag2 = this.useConstructor; + if (flag2) + { + bool flag3 = !this.hasConstructor; + if (flag3) + { + TypeModel.ThrowCannotCreateInstance(this.constructType); + } + obj = Activator.CreateInstance(this.constructType, true); + } + else + { + obj = BclHelpers.GetUninitializedObject(this.constructType); + } + } + ProtoReader.NoteObject(obj, source); + bool flag4 = this.baseCtorCallbacks != null; + if (flag4) + { + for (int i = 0; i < this.baseCtorCallbacks.Length; i++) + { + this.InvokeCallback(this.baseCtorCallbacks[i], obj, source.Context); + } + } + bool flag5 = includeLocalCallback && this.callbacks != null; + if (flag5) + { + this.InvokeCallback(this.callbacks.BeforeDeserialize, obj, source.Context); + } + return obj; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs.meta new file mode 100644 index 00000000..f8570d91 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/TypeSerializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ef593d3c48d31404290d6442b94fe22c +timeCreated: 1611404803 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs new file mode 100644 index 00000000..7819e0a6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal class UInt16Serializer : IProtoSerializer + { + public virtual Type ExpectedType + { + get + { + return UInt16Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(ushort); + + public UInt16Serializer(TypeModel model) + { + } + + public virtual object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadUInt16(); + } + + public virtual void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteUInt16((ushort)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs.meta new file mode 100644 index 00000000..f66f3529 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt16Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 70340302d41d7a34780704e67a77cd8f +timeCreated: 1611403931 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs new file mode 100644 index 00000000..1f63d4d8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class UInt32Serializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return UInt32Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(uint); + + public UInt32Serializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadUInt32(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteUInt32((uint)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs.meta new file mode 100644 index 00000000..da05d5e0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt32Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f5eebc15e3c087148b1105452e3d6d7a +timeCreated: 1611404878 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs new file mode 100644 index 00000000..82790b63 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs @@ -0,0 +1,49 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class UInt64Serializer : IProtoSerializer + { + public Type ExpectedType + { + get + { + return UInt64Serializer.expectedType; + } + } + + bool IProtoSerializer.RequiresOldValue + { + get + { + return false; + } + } + + bool IProtoSerializer.ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(ulong); + + public UInt64Serializer(TypeModel model) + { + } + + public object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + return source.ReadUInt64(); + } + + public void Write(object value, ProtoWriter dest) + { + ProtoWriter.WriteUInt64((ulong)value, dest); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs.meta new file mode 100644 index 00000000..c978dfa5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UInt64Serializer.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: f3cd11be3380d8a4590384028ff49928 +timeCreated: 1611404850 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs new file mode 100644 index 00000000..4150a604 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs @@ -0,0 +1,50 @@ +using System; +using ProtoBuf.Meta; + +namespace ProtoBuf.Serializers +{ + internal sealed class UriDecorator : ProtoDecoratorBase + { + public override Type ExpectedType + { + get + { + return UriDecorator.expectedType; + } + } + + public override bool RequiresOldValue + { + get + { + return false; + } + } + + public override bool ReturnsValue + { + get + { + return true; + } + } + + private static readonly Type expectedType = typeof(Uri); + + public UriDecorator(TypeModel model, IProtoSerializer tail) : base(tail) + { + } + + public override void Write(object value, ProtoWriter dest) + { + this.Tail.Write(((Uri)value).AbsoluteUri, dest); + } + + public override object Read(object value, ProtoReader source) + { + Helpers.DebugAssert(value == null); + string text = (string)this.Tail.Read(null, source); + return (text.Length == 0) ? null : new Uri(text); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs.meta new file mode 100644 index 00000000..6ae76887 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializers/UriDecorator.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 7e8f0a6082ce473469fae71e5d46f51c +timeCreated: 1611404005 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs new file mode 100644 index 00000000..7c7931ac --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs @@ -0,0 +1,14 @@ +using System; + +namespace ProtoBuf +{ + public struct SubItemToken + { + internal readonly int value; + + internal SubItemToken(int value) + { + this.value = value; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs.meta new file mode 100644 index 00000000..a17fc881 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/SubItemToken.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: df34e0fc616583c428069d9235d73d5d +timeCreated: 1611404692 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs new file mode 100644 index 00000000..21502a03 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs @@ -0,0 +1,15 @@ +using System; + +namespace ProtoBuf +{ + internal enum TimeSpanScale + { + Days, + Hours, + Minutes, + Seconds, + Milliseconds, + Ticks, + MinMax = 15 + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs.meta new file mode 100644 index 00000000..ac617b0d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/TimeSpanScale.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: b7a52b65fa07a8b45b8d40f98e7c87a4 +timeCreated: 1611404402 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs new file mode 100644 index 00000000..29ee7af0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs @@ -0,0 +1,16 @@ +using System; + +namespace ProtoBuf +{ + public enum WireType + { + None = -1, + Variant, + Fixed64, + String, + StartGroup, + EndGroup, + Fixed32, + SignedVariant = 8 + } +} diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs.meta b/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs.meta new file mode 100644 index 00000000..a35fd116 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/WireType.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: d843191b1a943424b934b60da2ebbf44 +timeCreated: 1611404638 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.1-26-g67d0