public TypeSerializer(TypeModel model, Type forType, int[] fieldNumbers, IProtoSerializer[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, CallbackSet callbacks, Type constructType, MethodInfo factory) { Helpers.Sort(fieldNumbers, serializers); bool flag = false; for (int i = 1; i < fieldNumbers.Length; i++) { if (fieldNumbers[i] == fieldNumbers[i - 1]) { throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i].ToString() + " on: " + forType.FullName); } if (!flag && serializers[i].ExpectedType != forType) { flag = true; } } this.forType = forType; this.factory = factory; if (constructType == (Type)null) { constructType = forType; } else if (!forType.IsAssignableFrom(constructType)) { 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; if (baseCtorCallbacks != null && baseCtorCallbacks.Length == 0) { baseCtorCallbacks = null; } this.baseCtorCallbacks = baseCtorCallbacks; if (Helpers.GetUnderlyingType(forType) != (Type)null) { throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType"); } if (model.MapType(iextensible).IsAssignableFrom(forType)) { if ((forType.IsValueType || !isRootType) | flag) { throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance"); } isExtensible = true; } hasConstructor = (!constructType.IsAbstract && Helpers.GetConstructor(constructType, Helpers.EmptyTypes, true) != (ConstructorInfo)null); if (!(constructType != forType & useConstructor)) { return; } if (hasConstructor) { return; } throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, "constructType"); }
private void Send(Frame frame, CallbackSet cbSet) { if (!port.IsOpen) { cbSet.ErrorHandler?.Invoke(TappyError.Hardware); } Callback flushAndSend = (byte[] data) => { Flush(); ackCb = cbSet.AckHandler; nackCb = cbSet.ErrorHandler; lcsErrorResponseCb = cbSet.ErrorHandler; dcsErrorResponseCb = cbSet.ErrorHandler; validResponseFrameCb = cbSet.SuccessHandler; appErrorCb = cbSet.ErrorHandler; UnSafeSend(frame); }; validResponseFrameCb = ackCb = flushAndSend; dcsErrorResponseCb = lcsErrorResponseCb = nackCb = appErrorCb = (TappyError errorCode, byte[] data) => { if (data.Length > 0 && data[0] == Driver.CMD.STOP) { Debug.WriteLine("Unrecogized command for stop, this Tappy probably predates stop"); } flushAndSend(); }; Stop(); }
private static void EmitInvokeCallback(CompilerContext ctx, MethodInfo method, bool copyValue, Type constructType, Type type) { if (method != null) { if (copyValue) { ctx.CopyValue(); } ParameterInfo[] parameters = method.GetParameters(); bool flag = true; for (int i = 0; i < parameters.Length; i++) { Type parameterType = parameters[0].ParameterType; if (parameterType == ctx.MapType(typeof(SerializationContext))) { ctx.LoadSerializationContext(); } else if (parameterType == ctx.MapType(typeof(Type))) { Type type3 = constructType; if (type3 == null) { type3 = type; } ctx.LoadValue(type3); } else if (parameterType == ctx.MapType(typeof(StreamingContext))) { ctx.LoadSerializationContext(); MethodInfo info = ctx.MapType(typeof(SerializationContext)).GetMethod("op_Implicit", new Type[] { ctx.MapType(typeof(SerializationContext)) }); if (info != null) { ctx.EmitCall(info); flag = true; } } else { flag = false; } } if (!flag) { throw CallbackSet.CreateInvalidCallbackSignature(method); } ctx.EmitCall(method); if ((constructType != null) && (method.ReturnType == ctx.MapType(typeof(object)))) { ctx.CastFromObject(type); } } }
private object InvokeCallback(MethodInfo method, object obj, SerializationContext context) { object obj2 = null; object[] objArray; bool flag; if (method == null) { return(obj2); } ParameterInfo[] parameters = method.GetParameters(); if (parameters.Length == 0) { objArray = null; flag = true; } else { objArray = new object[parameters.Length]; flag = true; for (int i = 0; i < objArray.Length; i++) { object constructType; Type parameterType = parameters[i].ParameterType; if (parameterType == typeof(SerializationContext)) { constructType = context; } else if (parameterType == typeof(Type)) { constructType = this.constructType; } else if (parameterType == typeof(StreamingContext)) { constructType = (StreamingContext)context; } else { constructType = null; flag = false; } objArray[i] = constructType; } } if (!flag) { throw CallbackSet.CreateInvalidCallbackSignature(method); } return(method.Invoke(obj, objArray)); }
public TypeSerializer(Type forType, int[] fieldNumbers, IProtoSerializer[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, CallbackSet callbacks) { Helpers.DebugAssert(forType != null); Helpers.DebugAssert(fieldNumbers != null); Helpers.DebugAssert(serializers != null); Helpers.DebugAssert(fieldNumbers.Length == serializers.Length); Helpers.Sort(fieldNumbers, serializers); bool hasSubTypes = false; for (int i = 1; i < fieldNumbers.Length; i++) { if (fieldNumbers[i] == fieldNumbers[i - 1]) { throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i].ToString() + " on: " + forType.FullName); } if (!hasSubTypes && serializers[i].ExpectedType != forType) { hasSubTypes = true; } } this.forType = forType; this.serializers = serializers; this.fieldNumbers = fieldNumbers; this.callbacks = callbacks; this.isRootType = isRootType; this.useConstructor = useConstructor; if (baseCtorCallbacks != null && baseCtorCallbacks.Length == 0) { baseCtorCallbacks = null; } this.baseCtorCallbacks = baseCtorCallbacks; #if !NO_GENERICS if (Nullable.GetUnderlyingType(forType) != null) { throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType"); } #endif if (typeof(IExtensible).IsAssignableFrom(forType)) { if (forType.IsValueType || !isRootType || hasSubTypes) { throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance"); } isExtensible = true; } }
private object InvokeCallback(MethodInfo method, object obj, SerializationContext context) { object result = null; if (method != (MethodInfo)null) { ParameterInfo[] parameters = method.GetParameters(); object[] array; bool flag; if (parameters.Length == 0) { array = null; flag = true; } else { array = new object[parameters.Length]; flag = true; for (int i = 0; i < array.Length; i++) { Type parameterType = parameters[i].ParameterType; object obj2; if (parameterType == typeof(SerializationContext)) { obj2 = context; } else if (parameterType == typeof(Type)) { obj2 = constructType; } else { obj2 = null; flag = false; } array[i] = obj2; } } if (flag) { result = method.Invoke(obj, array); goto IL_00a1; } throw CallbackSet.CreateInvalidCallbackSignature(method); } goto IL_00a1; IL_00a1: return(result); }
static void ChangeCallbackSet(SerializableGuid clipGuid, Action <CallbackSet> modification) { if (!clipGuid.IsSet()) { return; } CallbackSet callbackSet; if (!s_CallbackSetsPerClip.TryGetValue(clipGuid, out callbackSet)) { callbackSet = new CallbackSet(); s_CallbackSetsPerClip.Add(clipGuid, callbackSet); } modification?.Invoke(callbackSet); }
internal void VerifyFactory(MethodInfo factory, Type type) { if (factory != null) { if (type != null && Helpers.IsValueType(type)) { throw new InvalidOperationException(); } if (!factory.IsStatic) { throw new ArgumentException("A factory-method must be static", "factory"); } if (type != null && factory.ReturnType != type && factory.ReturnType != base.MapType(typeof(object))) { throw new ArgumentException("The factory-method must return object" + ((type == null) ? "" : (" or " + type.FullName)), "factory"); } if (!CallbackSet.CheckCallbackParameters(this, factory)) { throw new ArgumentException("Invalid factory signature in " + factory.DeclaringType.FullName + "." + factory.Name, "factory"); } } }
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 hasSubTypes = false; for (int i = 1; i < fieldNumbers.Length; i++) { if (fieldNumbers[i] == fieldNumbers[i - 1]) { throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i].ToString() + " on: " + forType.FullName); } if (!hasSubTypes && serializers[i].ExpectedType != forType) { hasSubTypes = true; } } this.forType = forType; this.factory = factory; #if WINRT this.typeInfo = forType.GetTypeInfo(); #endif if (constructType == null) { constructType = forType; } else { #if WINRT if (!typeInfo.IsAssignableFrom(constructType.GetTypeInfo())) #else if (!forType.IsAssignableFrom(constructType)) #endif { 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; if (baseCtorCallbacks != null && baseCtorCallbacks.Length == 0) { baseCtorCallbacks = null; } this.baseCtorCallbacks = baseCtorCallbacks; #if !NO_GENERICS if (Helpers.GetUnderlyingType(forType) != null) { throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType"); } #endif #if WINRT if (iextensible.IsAssignableFrom(typeInfo)) { if (typeInfo.IsValueType || !isRootType || hasSubTypes) #else if (model.MapType(iextensible).IsAssignableFrom(forType)) { if (forType.IsValueType || !isRootType || hasSubTypes) #endif { throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance"); } isExtensible = true; } #if WINRT TypeInfo constructTypeInfo = constructType.GetTypeInfo(); hasConstructor = !constructTypeInfo.IsAbstract && Helpers.GetConstructor(constructTypeInfo, Helpers.EmptyTypes, true) != null; #else hasConstructor = !constructType.IsAbstract && Helpers.GetConstructor(constructType, Helpers.EmptyTypes, true) != null; #endif if (constructType != forType && useConstructor && !hasConstructor) { throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, "constructType"); } }
public TypeSerializer(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 hasSubTypes = false; for (int i = 0; i < fieldNumbers.Length; i++) { if (i != 0 && fieldNumbers[i] == fieldNumbers[i - 1]) { throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i].ToString() + " on: " + forType.FullName); } if (!hasSubTypes && serializers[i].ExpectedType != forType) { hasSubTypes = true; } } ExpectedType = forType; this.factory = factory; if (constructType == null) { constructType = forType; } else { if (!forType.IsAssignableFrom(constructType)) { 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; if (baseCtorCallbacks != null) { foreach (var cb in baseCtorCallbacks) { if (!cb.ReflectedType.IsAssignableFrom(forType)) { throw new InvalidOperationException("Trying to assign incompatible callback to " + forType.FullName); } } if (baseCtorCallbacks.Length == 0) { baseCtorCallbacks = null; } } this.baseCtorCallbacks = baseCtorCallbacks; if (Helpers.GetUnderlyingType(forType) != null) { throw new ArgumentException("Cannot create a TypeSerializer for nullable types", nameof(forType)); } if (iextensible.IsAssignableFrom(forType)) { if (forType.IsValueType || !isRootType || hasSubTypes) { throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance"); } isExtensible = true; } hasConstructor = !constructType.IsAbstract && Helpers.GetConstructor(constructType, Helpers.EmptyTypes, true) != null; if (constructType != forType && useConstructor && !hasConstructor) { throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, nameof(constructType)); } }
public TypeSerializer(TypeModel model, Type forType, long[] fieldNumbers, IProtoSerializer[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, CallbackSet callbacks, Type constructType, MethodInfo factory)
abstract internal void Init(int[] fieldNumbers, IRuntimeProtoSerializerNode[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, bool assertKnownType, CallbackSet callbacks, Type constructType, MethodInfo factory, SerializerFeatures features);
public static IProtoTypeSerializer Create(Type forType, int[] fieldNumbers, IRuntimeProtoSerializerNode[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, bool assertKnownType, CallbackSet callbacks, Type constructType, MethodInfo factory, Type rootType, SerializerFeatures features) { var obj = (TypeSerializer)(rootType != null ? Activator.CreateInstance(typeof(InheritanceTypeSerializer <,>).MakeGenericType(rootType, forType), nonPublic: true) : Activator.CreateInstance(typeof(TypeSerializer <>).MakeGenericType(forType), nonPublic: true)); obj.Init(fieldNumbers, serializers, baseCtorCallbacks, isRootType, useConstructor, assertKnownType, callbacks, constructType, factory, features); return((IProtoTypeSerializer)obj); }