// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica private void RegisterHardCodedTypes() { Model.Add(typeof(Light), true); Model.Add(typeof(BoxCollider), true); Model.Add(typeof(SphereCollider), true); Model.Add(typeof(MeshCollider), true); Model.Add(typeof(Vector3), false).SetSurrogate(typeof(Vector3Surrogate)); Model.Add(typeof(NitroxVector3), false).SetSurrogate(typeof(Vector3Surrogate)); Model.Add(typeof(Quaternion), false).SetSurrogate(typeof(QuaternionSurrogate)); Model.Add(typeof(NitroxQuaternion), false).SetSurrogate(typeof(QuaternionSurrogate)); Model.Add(typeof(Transform), false).SetSurrogate(typeof(NitroxTransform)); Model.Add(typeof(GameObject), false).SetSurrogate(typeof(NitroxServer.UnityStubs.GameObject)); MetaType vehicleModel = Model.Add(typeof(VehicleModel), false); vehicleModel.AddSubType(100, typeof(ExosuitModel)); vehicleModel.AddSubType(200, typeof(SeamothModel)); vehicleModel.AddSubType(300, typeof(CyclopsModel)); vehicleModel.AddSubType(400, typeof(NeptuneRocketModel)); MetaType movementData = Model.Add(typeof(VehicleMovementData), false); movementData.AddSubType(100, typeof(ExosuitMovementData)); MetaType rotationData = Model.Add(typeof(RotationMetadata), false); rotationData.AddSubType(50, typeof(CorridorRotationMetadata)); rotationData.AddSubType(60, typeof(MapRoomRotationMetadata)); rotationData.AddSubType(70, typeof(BaseModuleRotationMetadata)); rotationData.AddSubType(80, typeof(AnchoredFaceRotationMetadata)); }
public static void AddType(Type t, Action <object, string> action) { ushort number = GetInt16HashCode(t.FullName); if (t.IsDefined(typeof(SynchronizableAttribute), false)) { model.Add(t, true); type.AddSubType(number, t); } typesDictionary.Add(t, number); types.Add(number, t); typesActions.Add(number, action); }
private void RegisterHardCodedTypes() { model.Add(typeof(UnityEngine.Light), true); model.Add(typeof(UnityEngine.BoxCollider), true); model.Add(typeof(UnityEngine.SphereCollider), true); model.Add(typeof(UnityEngine.MeshCollider), true); model.Add(typeof(UnityEngine.Vector3), false).SetSurrogate(typeof(UnityStubs.Vector3)); model.Add(typeof(UnityEngine.Quaternion), false).SetSurrogate(typeof(UnityStubs.Quaternion)); model.Add(typeof(UnityEngine.Transform), false).SetSurrogate(typeof(UnityStubs.Transform)); model.Add(typeof(UnityEngine.GameObject), false).SetSurrogate(typeof(UnityStubs.GameObject)); MetaType metaType = model.Add(typeof(RotationMetadata), false); metaType.AddSubType(50, typeof(CorridorRotationMetadata)); metaType.AddSubType(60, typeof(MapRoomRotationMetadata)); }
// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica private void RegisterHardCodedTypes() { MetaType vehicleModel = Model.Add(typeof(VehicleModel), false); vehicleModel.AddSubType(100, typeof(ExosuitModel)); vehicleModel.AddSubType(200, typeof(SeamothModel)); vehicleModel.AddSubType(300, typeof(CyclopsModel)); MetaType movementData = Model.Add(typeof(VehicleMovementData), false); movementData.AddSubType(100, typeof(ExosuitMovementData)); MetaType rotationData = Model.Add(typeof(RotationMetadata), false); rotationData.AddSubType(50, typeof(CorridorRotationMetadata)); rotationData.AddSubType(60, typeof(MapRoomRotationMetadata)); }
public static MetaType AddCurrencies(this MetaType metaType, ICurrencies currencies) { for (var i = 0; i < currencies.Count; ++i) { metaType.AddSubType(i + 1, currencies[i].GetType()); } return(metaType); }
private static void AddSubTypes(Type parentType, MetaType metaType, RuntimeTypeModel typeModel, IEnumerable <Assembly> assemblies) { foreach (var childType in GetBaseTypesOfParentInAssemblies(parentType, assemblies)) { var subModel = typeModel.Add(childType, true); metaType.AddSubType(_field, childType); Interlocked.Increment(ref _field); AddSubTypes(parentType, subModel, typeModel, assemblies); } }
// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica private void RegisterHardCodedTypes() { MetaType vehicleModel = Model.Add(typeof(VehicleModel), false); vehicleModel.AddSubType(100, typeof(ExosuitModel)); MetaType movementData = Model.Add(typeof(VehicleMovementData), false); movementData.AddSubType(100, typeof(ExosuitMovementData)); }
static Command() { try { // Get all CommandHandler subclasses in the CSM.Commands.Handler namespace Type[] handlers = typeof(Command).Assembly.GetTypes() .Where(t => t.Namespace != null) .Where(t => t.Namespace.StartsWith("CSM.Commands.Handler", StringComparison.Ordinal)) .Where(t => t.IsSubclassOf(typeof(CommandHandler))) .Where(t => !t.IsAbstract) .ToArray(); // Create a protobuf model RuntimeTypeModel model = TypeModel.Create(); // Set type surrogates model[typeof(Vector3)].SetSurrogate(typeof(Vector3Surrogate)); model[typeof(NetTool.ControlPoint)].SetSurrogate(typeof(ControlPointSurrogate)); // Add Quaternion Surrogate model[typeof(Quaternion)].SetSurrogate(typeof(QuaternionSurrogate)); // Add Color Surrogate model[typeof(Color)].SetSurrogate(typeof(ColorSurrogate)); // Add base command to the protobuf model with all attributes model.Add(typeof(CommandBase), true); MetaType baseCmd = model[typeof(CommandBase)]; // Lowest id of the subclasses int id = 100; // Create instances of the handlers, initialize mappings and register command subclasses in the protobuf model foreach (Type type in handlers) { CommandHandler handler = (CommandHandler)Activator.CreateInstance(type); _cmdMapping.Add(handler.GetDataType(), handler); // Add subtype to the protobuf model with all attributes baseCmd.AddSubType(id, handler.GetDataType()); model.Add(handler.GetDataType(), true); id++; } // Compile the protobuf model model.CompileInPlace(); Model = model; } catch (Exception ex) { _logger.Error(ex, "Failed to initialize data model"); } }
public static RuntimeTypeModel Create() { RuntimeTypeModel model = TypeModel.Create(); RegisterAutoTypes(model); RegisterUserDefinedTypes(model); Type[] serializableTypes = Reflection.GetAllFromCurrentAssembly() .Where(type => type.IsDefined(typeof(ProtoContractAttribute), false)).ToArray(); MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false); int fieldNumber = 16; foreach (Type type in serializableTypes) { if (type.IsGenericType()) { continue; } Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType()); primitiveContract.AddSubType(fieldNumber, derivedType); fieldNumber++; model.Add(derivedType, true); model.Add(typeof(List <>).MakeGenericType(type), true); } Type[] primitiveTypes = new[] { typeof(bool), typeof(char), typeof(byte), typeof(short), typeof(int), typeof(long), typeof(ushort), typeof(uint), typeof(ulong), typeof(string), typeof(float), typeof(double), typeof(decimal) }; foreach (Type type in primitiveTypes) { if (type.IsGenericType()) { continue; } model.Add(typeof(List <>).MakeGenericType(type), true); } return(model); }
internal static void Init() { model = RuntimeTypeModel.Default; type = model.Add(typeof(ISync), true); var containerType = type.AddSubType(6, typeof(Container)); containerType.AddSubType(1, typeof(StringContainer)); typesActions.Add(1, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(string))) { typesActions[typesDictionary[typeof(string)]].Invoke((data as StringContainer).value, senderID); } }); typesDictionary.Add(typeof(StringContainer), 1); types.Add(1, typeof(StringContainer)); containerType.AddSubType(2, typeof(IntContainer)); typesActions.Add(2, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(int))) { typesActions[typesDictionary[typeof(int)]].Invoke((data as IntContainer).value, senderID); } }); typesDictionary.Add(typeof(IntContainer), 2); types.Add(2, typeof(IntContainer)); containerType.AddSubType(3, typeof(UintContainer)); typesActions.Add(3, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(uint))) { typesActions[typesDictionary[typeof(uint)]].Invoke((data as UintContainer).value, senderID); } }); typesDictionary.Add(typeof(UintContainer), 3); types.Add(3, typeof(UintContainer)); containerType.AddSubType(4, typeof(FloatContainer)); typesActions.Add(4, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(float))) { typesActions[typesDictionary[typeof(float)]].Invoke((data as FloatContainer).value, senderID); } }); typesDictionary.Add(typeof(FloatContainer), 4); types.Add(4, typeof(FloatContainer)); containerType.AddSubType(5, typeof(DoubleContainer)); typesActions.Add(5, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(double))) { typesActions[typesDictionary[typeof(double)]].Invoke((data as DoubleContainer).value, senderID); } }); typesDictionary.Add(typeof(DoubleContainer), 5); types.Add(5, typeof(DoubleContainer)); }
// Token: 0x06000C7E RID: 3198 RVA: 0x00025F7C File Offset: 0x0002417C public void AddTypeToSerializer(Type parent, Type type) { if (type == null || parent == null) { throw new ArgumentNullException(); } if (!RuntimeTypeModel.Default[parent].GetSubtypes().Any((SubType subType) => subType.DerivedType.Type == type)) { MetaType metaType = RuntimeTypeModel.Default[parent]; int typeIndex = this._typeIndex; this._typeIndex = typeIndex + 1; metaType.AddSubType(typeIndex, type); } }
public static void LoadSerialization() { //Add subtypes if (!RuntimeTypeModel.Default.IsDefined(typeof(NetworkEntityData))) { MetaType entityDataType = RuntimeTypeModel.Default.Add(typeof(NetworkEntityData), false).Add(GetFields(typeof(NetworkEntityData))); entityDataType.UseConstructor = false; Type[] subTypes = Assembly.GetAssembly(typeof(NetworkEntityData)).GetTypes().Where(t => (t.IsSubclassOf(typeof(NetworkEntityData)))).ToArray(); for (int i = 0; i < subTypes.Length; i++) { RuntimeTypeModel.Default.Add(subTypes[i], false).Add(GetFields(subTypes[i])).UseConstructor = false; entityDataType.AddSubType(INDEX_OFFSET + i, subTypes[i]); } } }
public void InitialStartup(ref int progress) { RuntimeTypeModel current = RuntimeTypeModel.Create(); foreach (ITeachSerialization item in this.Teachers) { item.Teach(current);//Point teacher ain't loading progress++; } MetaType baseMessageType = current.Add(typeof(BaseMessage), true); // = ReflectionUtil.LoadAllInterface<IHasSubclasses>(Assembly.GetAssembly(typeof(BaseMessage))); List <IHasSubclasses> ToProcess = new List <IHasSubclasses>(); ToProcess.AddRange(ReflectionUtil.LoadAllInterface <IHasSubclasses>(Assembly.GetAssembly(typeof(Tile)))); foreach (IHasSubclasses item in ToProcess) { MetaType meta = current.Add(item.GetBaseType(), true); foreach (KeyValuePair <Type, int> subs in item.GetSubclassInformation()) { meta.AddSubType(subs.Value, subs.Key); } } //Must start at 2 because Protobuf-net can't have members and inheritance attributes with the same ID. I think. :D int i = 2; int length = this.Messages.Count + 2; while (i < length) { current.Add(this.Messages[i - 2], true); baseMessageType.AddSubType(i, this.Messages[i - 2]); BaseMessage sample = (BaseMessage)Activator.CreateInstance(this.Messages[i - 2]); ProtoUtil.IDToMessage.Add(sample.ID, this.Messages[i - 2]); i++; progress++; } //ProtoUtil.TypeModel = RuntimeTypeModel.Default. //ProtoUtil.TypeModel = current.Compile(); //ProtoUtil.TypeModel ProtoUtil.TypeModel = current; }
// Token: 0x06000AFD RID: 2813 RVA: 0x000225A8 File Offset: 0x000207A8 public static void PopulateTypes(Type t) { using (IEnumerator enumerator = RuntimeTypeModel.Default.GetTypes().GetEnumerator()) { while (enumerator.MoveNext()) { MetaType metaType; if ((metaType = (enumerator.Current as MetaType)) != null && metaType.Type == t) { return; } } } Type typeFromHandle = typeof(object); List <Type> list = new List <Type>(); do { list.Insert(0, t); t = t.BaseType; }while (t != null && t != typeFromHandle); for (int i = 0; i < list.Count - 1; i++) { Type type = list[i]; MetaType metaType2 = null; bool flag = false; RuntimeTypeModel @default = RuntimeTypeModel.Default; foreach (object obj in ((@default != null) ? @default.GetTypes() : null)) { MetaType metaType3 = (MetaType)obj; if (metaType3.Name.Equals(type.Name)) { flag = true; metaType2 = metaType3; break; } } if (!flag) { RuntimeTypeModel default2 = RuntimeTypeModel.Default; metaType2 = ((default2 != null) ? default2.Add(type, true) : null); } metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]); } }
/// <summary> /// Adds a default protobuf data contract to the protobuf runtime model /// </summary> /// <param name="allTypes">All types available</param> /// <param name="type">The type to add to the model</param> private static void AddProtobufType(Type[] allTypes, Type type) { MetaType metaType = RuntimeTypeModel.Default.Add(type, true); string[] memberNames = (from pi in type.GetProperties() where pi.CanWrite select pi.Name).ToArray(); metaType.Add(memberNames); int index = memberNames.Length; // add subtypes foreach (Type allType in allTypes) { if (allType.IsSubclassOf(type)) { metaType.AddSubType(++index, allType); } } }
public static void PopulateTypes(Type t) { foreach (object type2 in RuntimeTypeModel.Default.GetTypes()) { MetaType metaType; if ((metaType = (type2 as MetaType)) != null && metaType.Type == t) { return; } } Type typeFromHandle = typeof(object); List <Type> list = new List <Type>(); do { list.Insert(0, t); t = t.BaseType; }while (t != null && t != typeFromHandle); for (int i = 0; i < list.Count - 1; i++) { Type type = list[i]; MetaType metaType2 = null; bool flag = false; foreach (MetaType item in RuntimeTypeModel.Default?.GetTypes()) { if (item.Name.Equals(type.Name)) { flag = true; metaType2 = item; break; } } if (!flag) { metaType2 = RuntimeTypeModel.Default?.Add(type, applyDefaultBehaviour: true); } metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]); } }
public static void InitialiseSerializer() { if (!m_isInitialised) { m_isInitialised = true; Type packetType = typeof(Packet); Assembly protocolAssembly = Assembly.GetAssembly(packetType); Type[] types = protocolAssembly.GetTypes(); MetaType metaType = RuntimeTypeModel.Default.Add(packetType, true); //Count how many ProtoMembers Packet has and start tagging from there int startTag = packetType.GetProperties().Where(p => p.GetCustomAttributes(typeof(ProtoMemberAttribute), false).Count() > 0).Count() + 1; foreach (Type packetSubclass in types.Where(t => t.IsSubclassOf(packetType))) { metaType.AddSubType(startTag++, packetSubclass); } RuntimeTypeModel.Default.CompileInPlace(); RuntimeTypeModel.Default.AutoCompile = true; } }
public void RegisterInheritance(Type derivedType) { Meta.AddSubType(Tag++, derivedType); }
public static RuntimeTypeModel CreateTypeModel() { RuntimeTypeModel model = TypeModel.Create(); model.Add(typeof(IntArray), true); model.Add(typeof(ProjectItem), true) .AddSubType(1025, typeof(AssetItem)); model.Add(typeof(AssetItem), true); model.Add(typeof(AssetBundleItemInfo), true); model.Add(typeof(AssetBundleInfo), true); model.Add(typeof(ProjectInfo), true); model.Add(typeof(PrefabPart), true); model.Add(typeof(Preview), true); model.Add(typeof(PersistentDescriptor <long>), true); model.Add(typeof(PersistentPersistentCall <long>), true); model.Add(typeof(PersistentArgumentCache <long>), true); model.Add(typeof(PersistentBlendShapeFrame <long>), true); model.Add(typeof(PersistentBlendShapeFrame <Guid>), true); model.Add(typeof(PersistentDescriptor <Guid>), true); model.Add(typeof(PersistentPersistentCall <Guid>), true); model.Add(typeof(PersistentArgumentCache <Guid>), true); ITypeModelCreator typeModelCreator = IOC.Resolve <ITypeModelCreator>(); if (typeModelCreator == null) { DefaultTypeModel(model); } else { typeModelCreator.Create(model); } MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false); int fieldNumber = 16; //NOTE: Items should be added to TypeModel in exactly the same order!!! //It is allowed to append new types, but not to insert new types in the middle. Type[] types = new[] { typeof(bool), typeof(char), typeof(byte), typeof(short), typeof(int), typeof(long), typeof(ushort), typeof(uint), typeof(ulong), typeof(string), typeof(float), typeof(double), typeof(decimal), typeof(PersistentColor <long>), typeof(PersistentVector4 <long>), typeof(Guid), typeof(PersistentColor <Guid>), typeof(PersistentVector4 <Guid>) }; foreach (Type type in types) { //if (type.IsGenericType()) //{ // continue; //} Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType()); primitiveContract.AddSubType(fieldNumber, derivedType); fieldNumber++; model.Add(derivedType, true); derivedType = typeof(PrimitiveContract <>).MakeGenericType(type); primitiveContract.AddSubType(fieldNumber, derivedType); fieldNumber++; model.Add(derivedType, true); model.Add(typeof(List <>).MakeGenericType(type), true); } //This is special kind of peristent object which can be used to serialize types using reflection. (This is required to serialize objects of type created at runtime for example) model.Add(typeof(PersistentRuntimeSerializableObject <long>), true); model[typeof(PersistentObject <long>)].AddSubType(1024, typeof(PersistentRuntimeSerializableObject <long>)); model.Add(typeof(PersistentRuntimeSerializableObject <Guid>), true); model[typeof(PersistentObject <Guid>)].AddSubType(1024, typeof(PersistentRuntimeSerializableObject <Guid>)); model.AutoAddMissingTypes = false; return(model); }
public virtual void ApplyDefaultBehaviour(MetaType metaType) { var type = metaType.Type; Type baseType = metaType.GetBaseType(); if (baseType != null && CanAutoAddType(baseType) && MetaType.CanHaveSubType(baseType)) { Model.FindOrAddAuto(baseType, true, false, false); } try { AttributeFamily family; TypeState mapped; { AttributeMap[] typeAttribs = AttributeMap.Create(Model, type, false); family = GetContractFamily(type, typeAttribs); mapped = TypeMapper.Map( new TypeArgsValue(type, typeAttribs, AcceptableAttributes, Model) { Family = family, ImplicitFallbackMode = ImplicitFallbackMode, }); foreach (var candidate in mapped.DerivedTypes) { if (metaType.IsValidSubType(candidate.Type)) { metaType.AddSubType(candidate.Tag, candidate.Type); } } metaType.ReplaceClientSettings(mapped.SettingsValue); } var partialMembers = mapped.PartialMembers; int dataMemberOffset = mapped.DataMemberOffset; int implicitFirstTag = mapped.ImplicitFirstTag; bool inferTagByName = mapped.InferTagByName; ImplicitFieldsMode implicitMode = mapped.ImplicitFields; family = mapped.Input.Family; MethodInfo[] callbacks = null; var members = new List <MappedMember>(); bool isEnum = Helpers.IsEnum(type); #if WINRT System.Collections.Generic.IEnumerable <MemberInfo> foundList; if (isEnum) { foundList = type.GetRuntimeFields().Where(x => x.IsStatic && x.IsPublic); } else { System.Collections.Generic.List <MemberInfo> list = new System.Collections.Generic.List <MemberInfo>(); foreach (PropertyInfo prop in type.GetRuntimeProperties()) { MethodInfo getter = Helpers.GetGetMethod(prop, false, false); if (getter != null && !getter.IsStatic) { list.Add(prop); } } foreach (FieldInfo fld in type.GetRuntimeFields()) { if (fld.IsPublic && !fld.IsStatic) { list.Add(fld); } } foreach (MethodInfo mthd in type.GetRuntimeMethods()) { if (mthd.IsPublic && !mthd.IsStatic) { list.Add(mthd); } } foundList = list; } #else MemberInfo[] foundList = type.GetMembers(isEnum ? BindingFlags.Public | BindingFlags.Static : BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (isEnum) { foundList = foundList.Where(x => x is FieldInfo).ToArray(); } #endif foreach (MemberInfo member in foundList) { if (member.DeclaringType != type) { continue; } var map = AttributeMap.Create(Model, member, true); { var args = new MemberArgsValue(member, map, AcceptableAttributes, Model) { DataMemberOffset = dataMemberOffset, Family = family, InferTagByName = inferTagByName, PartialMembers = partialMembers, IsEnumValueMember = isEnum }; PropertyInfo property; FieldInfo field; if ((property = member as PropertyInfo) != null) { bool isPublic = Helpers.GetGetMethod(property, false, false) != null; bool canBeMapped = isPublic || Helpers.GetGetMethod(property, true, true) != null; if (canBeMapped && (!mapped.ImplicitOnlyWriteable || Helpers.CheckIfPropertyWritable ( Model, property, implicitMode == ImplicitFieldsMode.AllProperties || implicitMode == ImplicitFieldsMode.AllFieldsAndProperties, false))) { switch (implicitMode) { case ImplicitFieldsMode.AllProperties: args.IsForced = true; break; case ImplicitFieldsMode.PublicProperties: if (isPublic) { args.IsForced = true; } break; case ImplicitFieldsMode.PublicFieldsAndProperties: if (isPublic) { args.IsForced = true; } break; case ImplicitFieldsMode.AllFieldsAndProperties: args.IsForced = true; break; } } var r = ApplyDefaultBehaviour_AddMembers(args); if (r != null) { if (!canBeMapped) { throw new MemberAccessException("Property " + property + " should be readable to be mapped."); } members.Add(r); } } else if ((field = member as FieldInfo) != null) { bool isPublic = field.IsPublic; if (!args.IsEnumValueMember) { switch (implicitMode) { case ImplicitFieldsMode.AllFields: args.IsForced = true; break; case ImplicitFieldsMode.PublicFields: if (isPublic) { args.IsForced = true; } break; case ImplicitFieldsMode.PublicFieldsAndProperties: if (isPublic) { args.IsForced = true; } break; case ImplicitFieldsMode.AllFieldsAndProperties: args.IsForced = true; break; } } var r = ApplyDefaultBehaviour_AddMembers(args); if (r != null) { members.Add(r); } } } MethodInfo method; if ((method = member as MethodInfo) != null) { AttributeMap[] memberAttribs = AttributeMap.Create(Model, method, false); if (memberAttribs != null && memberAttribs.Length > 0) { const int max = 11; if (CanUse(AttributeType.ProtoBuf)) { CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeSerializationAttribute", ref callbacks, 0, max); CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterSerializationAttribute", ref callbacks, 1, max); CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeDeserializationAttribute", ref callbacks, 2, max); CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterDeserializationAttribute", ref callbacks, 3, max); } CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializingAttribute", ref callbacks, 4, max); CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializedAttribute", ref callbacks, 5, max); CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializingAttribute", ref callbacks, 6, max); CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializedAttribute", ref callbacks, 7, max); if (CanUse(AttributeType.Aqla)) { CheckForCallback(method, memberAttribs, "AqlaSerializer.BeforeSerializationCallbackAttribute", ref callbacks, 8, max); CheckForCallback(method, memberAttribs, "AqlaSerializer.AfterSerializationCallbackAttribute", ref callbacks, 9, max); CheckForCallback(method, memberAttribs, "AqlaSerializer.BeforeDeserializationCallbackAttribute", ref callbacks, 10, max); CheckForCallback(method, memberAttribs, "AqlaSerializer.AfterDeserializationCallbackAttribute", ref callbacks, 11, max); } } } } if (inferTagByName || implicitMode != ImplicitFieldsMode.None) { members.Sort(); foreach (var member in members) { if (!member.MappingState.TagIsPinned) // if ProtoMember etc sets a tag, we'll trust it { member.Tag = -1; } } } foreach (var member in members.OrderBy(m => m.MappingState.TagIsPinned ? 0 : 1)) { ApplyDefaultBehaviour(metaType, member, (inferTagByName || implicitMode != ImplicitFieldsMode.None) ? (int?)implicitFirstTag : null); } if (callbacks != null) { metaType.SetCallbacks(Coalesce(callbacks, 0, 4, 8), Coalesce(callbacks, 1, 5, 9), Coalesce(callbacks, 2, 6, 10), Coalesce(callbacks, 3, 7, 11)); } if (!DisableAutoAddingMemberTypes) { foreach (var member in members) { if (!member.MappingState.Input.IsEnumValueMember) { Type memberType = Helpers.GetMemberType(member.Member); memberType = Helpers.GetNullableUnderlyingType(memberType) ?? memberType; if (memberType.IsArray) { memberType = memberType.GetElementType(); } memberType = TypeModel.GetListItemType(Model, memberType) ?? memberType; if (memberType == null) { continue; } if (CanAutoAddType(memberType)) { Model.FindOrAddAuto(memberType, true, false, false); } } } } if (UseLegacyTupleFields) { foreach (ValueMember vm in metaType.GetTupleFields()) { vm.SetSettings(x => x.V.DefaultsMode = MemberDefaultsMode.LegacyTuple); } } } finally { if (baseType != null && GetContractFamily(baseType) != AttributeFamily.None) { if (Model.FindWithoutAdd(baseType) != null) { MetaType baseMeta = Model[baseType]; // we can't add to frozen base type // but this is not always an error // e.g. dynamic member of base type doesn't need registered subtype if (!baseMeta.IsFrozen && !DisableAutoRegisteringSubtypes && !baseMeta.IsList && baseMeta.IsValidSubType(type) && CanAutoAddType(baseType)) { baseMeta.AddSubType(baseMeta.GetNextFreeFieldNumber(AutoRegisteringSubtypesFirstTag), type); } } } } }
public static void AddBaseTypeProtoMembers(MetaType metaType, Type derivedType) { //var myType = runtimeTypeModel[typeof(MachineTarget)]; metaType.AddSubType(100, derivedType); }
public static RuntimeTypeModel Create() { RuntimeTypeModel model = TypeModel.Create(); model.Add(typeof(IntArray), true); model.Add(typeof(ProjectItem), true) .AddSubType(1025, typeof(AssetItem)); model.Add(typeof(AssetItem), true); model.Add(typeof(AssetBundleItemInfo), true); model.Add(typeof(AssetBundleInfo), true); model.Add(typeof(ProjectInfo), true); model.Add(typeof(PrefabPart), true); model.Add(typeof(Preview), true); model.Add(typeof(PersistentDescriptor), true); model.Add(typeof(PersistentPersistentCall), true); model.Add(typeof(PersistentArgumentCache), true); RegisterAutoTypes(model); RegisterUserDefinedTypes(model); if (m_createDefaultTypeModel) { DefaultTypeModel(model); } MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false); int fieldNumber = 16; //NOTE: Items should be added to TypeModel in exactly the same order!!! //It is allowed to append new types, but not to insert new types in the middle. Type[] types = new[] { typeof(bool), typeof(char), typeof(byte), typeof(short), typeof(int), typeof(long), typeof(ushort), typeof(uint), typeof(ulong), typeof(string), typeof(float), typeof(double), typeof(decimal), typeof(PersistentColor), typeof(PersistentVector4) }; foreach (Type type in types) { if (type.IsGenericType()) { continue; } Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType()); primitiveContract.AddSubType(fieldNumber, derivedType); fieldNumber++; model.Add(derivedType, true); derivedType = typeof(PrimitiveContract <>).MakeGenericType(type); primitiveContract.AddSubType(fieldNumber, derivedType); fieldNumber++; model.Add(derivedType, true); model.Add(typeof(List <>).MakeGenericType(type), true); } model.AutoAddMissingTypes = false; return(model); }
public void Register(ILayoutSerializer buttonSerializer, MetaType edb) { layoutSerializers[buttonSerializer.LayoutElementType] = buttonSerializer; edb.AddSubType(layoutSerializers.Count, buttonSerializer.LayoutDataType); }
private bool InternalRegister(Type typeToRegister) { //Ok so here the fun begins. //We need a recursive algorithm for walking the graph of the Type to register each //serializable type. So, for every member we must look down into that Type recursively and register it. //However, we must make sure to check if it's already been registered or we might get circular graphs which //would overflow. But that'd be a weird type anyway. if (typeToRegister == null) { throw new ArgumentNullException(nameof(typeToRegister), $"Provided {typeToRegister} is a null arg."); } //Can't use isDefined exclusively but it'll fail when doing two-way subtypes if (registeredTypes.ContainsKey(typeToRegister)) { return(true); } if (typeof(IEnumerable).IsAssignableFrom(typeToRegister) || typeToRegister.IsArray) { if (typeToRegister.IsArray) { Register(typeToRegister.GetElementType()); } else { foreach (var gparam in typeToRegister.GetGenericArguments()) { Register(gparam); } } } //if (RuntimeTypeModel.Default.IsDefined(typeToRegister)) // return true; if (typeToRegister.IsEnum) { MetaType enumMetaType = RuntimeTypeModel.Default.Add(typeToRegister, false); enumMetaType.EnumPassthru = true; enumMetaType.AsReferenceDefault = false; return(true); } //If it's not defined we need to add it. if (typeToRegister.Attribute <GladNetSerializationContractAttribute>() == null) { return(false); } MetaType typeModel = RuntimeTypeModel.Default.Add(typeToRegister, false); //Add each member foreach (MemberInfo mi in typeToRegister.MembersWith <GladNetMemberAttribute>(MemberTypes.Field | MemberTypes.Property, Flags.InstanceAnyDeclaredOnly)) //keep this declare only because of Unity3D serialization issues with NetSendable { typeModel.Add(mi.Attribute <GladNetMemberAttribute>().TagID, mi.Name); //Now we might need to register this type aswell. //Recur to try to register this type Register(mi.Type()); } //If might have a include on it so we should check it to register it with the subtype IEnumerable <GladNetSerializationIncludeAttribute> includes = typeToRegister.Attributes <GladNetSerializationIncludeAttribute>(); foreach (GladNetSerializationIncludeAttribute include in includes) { //if we don't know about the type register it if (!registeredTypes.ContainsKey(include.TypeToWireTo)) { Register(include.TypeToWireTo); } //this is the simple case; however unlike protobuf we support two-include if (include != null && include.IncludeForDerived) { if (include.TypeToWireTo == typeModel.Type || !typeModel.Type.IsAssignableFrom(include.TypeToWireTo)) { continue; } else { typeModel.AddSubType(include.TagID, include.TypeToWireTo); } } else if (include != null && !include.IncludeForDerived) { //this is not for mappping a base type to setup mapping for its child //we need to map this child to its base //so we need to get the MetaType for it RuntimeTypeModel.Default[include.TypeToWireTo] .AddSubType(include.TagID, typeToRegister); } } registeredTypes.Add(typeToRegister, null); return(true); }
// Token: 0x060000F9 RID: 249 RVA: 0x00004008 File Offset: 0x00002208 public static void PopulateTypes(Type t) { using (IEnumerator enumerator = RuntimeTypeModel.Default.GetTypes().GetEnumerator()) { while (enumerator.MoveNext()) { MetaType metaType; if ((metaType = (enumerator.Current as MetaType)) != null && metaType.Type == t) { return; } } } Type typeFromHandle = typeof(object); List <Type> list = new List <Type>(); do { list.Insert(0, t); t = t.BaseType; if (t == null) { break; } }while (t != typeFromHandle); int i = 0; while (i < list.Count - 1) { Type type = list[i]; MetaType metaType2 = null; bool flag = false; RuntimeTypeModel expr_A3 = RuntimeTypeModel.Default; using (IEnumerator enumerator = ((expr_A3 != null) ? expr_A3.GetTypes() : null).GetEnumerator()) { while (enumerator.MoveNext()) { MetaType metaType3 = (MetaType)enumerator.Current; if (metaType3.Name.Equals(type.Name)) { flag = true; metaType2 = metaType3; break; } } goto IL_142; } goto IL_101; IL_117: metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]); i++; continue; IL_101: RuntimeTypeModel expr_106 = RuntimeTypeModel.Default; metaType2 = ((expr_106 != null) ? expr_106.Add(type, true) : null); goto IL_117; IL_142: if (!flag) { goto IL_101; } goto IL_117; } }