public void TypeModel_Struct_NonVirtualProperty() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(NonVirtualPropertyStruct <byte>))); }
/// <summary> /// Apply include mappings via assembly reflection (<see cref="ProtoBaseAttribute"/>).<br /> /// Important: This must be called before any serialization happen. /// </summary> /// <param name="model">The RuntimeTypeModel</param> /// <param name="assemblyRegexFilter">The regex assembly filer</param> /// <param name="implicitFields">The default import of base type fields, if nothing is specified.</param> /// <exception cref="ArgumentException"></exception> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="InvalidDataException"></exception> public static void ApplyProtoBase(this RuntimeTypeModel model, Regex assemblyRegexFilter, ImplicitFields implicitFields = ImplicitFields.AllPublic) { model.ApplyProtoBase(assembly => assemblyRegexFilter == null || assemblyRegexFilter.IsMatch(assembly.FullName), implicitFields); }
public static void Configure(RuntimeTypeModel model) { var type = model.Add(typeof(AgGateway.ADAPT.ApplicationDataModel.Guidance.Spiral), Constants.UseDefaults); type.AddField(305, nameof(AgGateway.ADAPT.ApplicationDataModel.Guidance.Spiral.Shape)); }
/// <summary> /// Applies a protocol-buffer stream to an existing instance, using length-prefixed /// data - useful with network IO. /// </summary> /// <typeparam name="T">The type being merged.</typeparam> /// <param name="instance">The existing instance to be modified (can be null).</param> /// <param name="source">The binary stream to apply to the instance (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <returns>The updated instance; this may be different to the instance argument if /// either the original instance was null, or the stream defines a known sub-type of the /// original instance.</returns> public static T MergeWithLengthPrefix <T>(Stream source, T instance, PrefixStyle style) { RuntimeTypeModel model = RuntimeTypeModel.Default; return((T)model.DeserializeWithLengthPrefix(source, instance, model.MapType(typeof(T)), style, 0)); }
public override void Work(RuntimeTypeModel model) { SetSurrogate <Color, ColorSurrogate>(model); }
public void TypeModel_Struct_VectorNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericStruct <Memory <byte> >))); }
public void TypeModel_Struct_Misnumbered() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(MisnumberedStruct <byte>))); }
public void TypeModel_Vector_VectorNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <IList <IList <int> > >))); }
public void TypeModel_Enum_UntaggedEnumNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(UntaggedEnum))); }
public void TypeModel_Struct_InterfaceImplementationVirtual() { RuntimeTypeModel.CreateFrom(typeof(InterfaceStructSuccess)); }
public void TypeModel_TypeCantBeTableAndStruct() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(InvalidTableAndStruct))); }
public void TypeModel_Struct_DefaultValue() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(StructWithDefaultValue))); }
public void TypeModel_Struct_Abstract() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(AbstractStruct <byte>))); }
public void TypeModel_Struct_DoesNotInheritFromObject() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(DoesNotInheritFromObjectStruct <byte>))); }
public void TypeModel_Table_InterfaceImplementationNonVirtual() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(InterfaceTableFailure))); }
public void TypeModel_SortedVector_OfScalar_NotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <int[]>))); }
public void TypeModel_Table_InterfaceImplementationVirtual() { RuntimeTypeModel.CreateFrom(typeof(InterfaceTableSuccess)); }
public void TypeModel_Table_UnrecognizedPropertyType() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <Dictionary <string, string> >))); }
public void TypeModel_Struct_UnionNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericStruct <FlatBufferUnion <string, GenericTable <string> > >))); }
public void TypeModel_SortedVector_OfTableWithEnumKey_NotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <IList <SortedVectorKeyTable <TaggedEnum> > >))); }
public static void Configure(RuntimeTypeModel model) { var type = model.Add(typeof(AgGateway.ADAPT.ApplicationDataModel.ReferenceLayers.ShapeReferenceLayer), Constants.UseDefaults); type.AddField(1, nameof(AgGateway.ADAPT.ApplicationDataModel.ReferenceLayers.ShapeReferenceLayer.ShapeLookups)); }
public void TypeModel_SortedVector_OfTableWithMultipleKeys_NotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(SortedVector <IList <SortedVectorMultiKeyTable <string> > >))); }
/// <summary> /// Writes a protocol-buffer representation of the given instance to the supplied stream, /// with a length-prefix. This is useful for socket programming, /// as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back /// from an ongoing stream. /// </summary> /// <typeparam name="T">The type being serialized.</typeparam> /// <param name="instance">The existing instance to be serialized (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <param name="destination">The destination stream to write to.</param> /// <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param> public static void SerializeWithLengthPrefix <T>(Stream destination, T instance, PrefixStyle style, int fieldNumber) { RuntimeTypeModel model = RuntimeTypeModel.Default; model.SerializeWithLengthPrefix(destination, instance, model.MapType(typeof(T)), style, fieldNumber); }
public void TypeModel_Table_DuplicateIndex() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(DuplicateNumberTable))); }
/// <summary> /// Apply include mappings via assembly reflection (<see cref="ProtoBaseAttribute"/>).<br /> /// Important: This must be called before any serialization happen. /// </summary> /// <param name="model">The RuntimeTypeModel</param> /// <param name="implicitFields">The default import of base type fields, if nothing is specified.</param> /// <exception cref="ArgumentException"></exception> /// <exception cref="InvalidDataException"></exception> public static void ApplyProtoBase(this RuntimeTypeModel model, ImplicitFields implicitFields = ImplicitFields.AllPublic) { model.ApplyProtoBase(assembly => true, implicitFields); }
public void TypeModel_Union_EnumsNotAllowed() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(GenericTable <FlatBufferUnion <string, TaggedEnum> >))); }
/// <summary> /// Apply include mappings via assembly reflection (<see cref="ProtoBaseAttribute"/>).<br /> /// Important: This must be called before any serialization happen. /// </summary> /// <param name="model">The RuntimeTypeModel</param> /// <param name="assemblyFilter">The custom assembly filter</param> /// <param name="implicitFields">The default import of base type fields, if nothing is specified.</param> /// <exception cref="ArgumentException"></exception> /// <exception cref="InvalidDataException"></exception> public static void ApplyProtoBase(this RuntimeTypeModel model, Func <Assembly, bool> assemblyFilter, ImplicitFields implicitFields = ImplicitFields.AllPublic) { AppDomain.CurrentDomain.GetAssemblies().Where(a => assemblyFilter?.Invoke(a) != false) .AsParallel().SelectMany(a => a.GetTypes().Where(t => t.IsClass && t.GetCustomAttributes <ProtoBaseAttribute>(false).Any())) .ForAll(t => { foreach (var attr in t.GetCustomAttributes <ProtoBaseAttribute>(false)) { if (attr.ConcreteType != null) { if (t.IsGenericType) { if (!attr.ConcreteType.IsGenericType || attr.ConcreteType.GetGenericTypeDefinition() != t) { throw new ArgumentException("Concrete type must be assignable from this type"); } } else if (!t.IsAssignableFrom(attr.ConcreteType)) { throw new ArgumentException("Concrete type must be assignable from this type"); } } var type = attr.ConcreteType ?? t; if (type.BaseType == null) { throw new ArgumentException("BaseType cannot be null"); } if (type.IsGenericType && type.GenericTypeArguments.Length == 0) { throw new InvalidDataException($"Cannot add generic type without concrete definition. '{type.FullName}'"); } Type baseType; if (attr.InterfaceType != null) { if (!attr.InterfaceType.IsInterface) { throw new ArgumentException($"The attributed InterfaceType must be an interface. '{attr.InterfaceType.FullName}'"); } if (!attr.InterfaceType.IsAssignableFrom(type)) { throw new ArgumentException( $"BaseType '{attr.InterfaceType.FullName}' must be assignable from type {type.FullName}."); } baseType = attr.InterfaceType; } else { if (type.BaseType == typeof(object)) { baseType = type.GetInterfaces().FirstOrDefault(); if (baseType == null) { throw new ArgumentException($"BaseType cannot be of type '{typeof(object).FullName}' and no interfaces are defined."); } } else { baseType = type.BaseType; } } var metaType = model.Add(type, true); if (metaType.BaseType != null && metaType.BaseType.Type != baseType) { throw new InvalidDataException( $"Type '{type.FullName}' has already an assigned base type '{metaType.BaseType.Type.FullName}'"); } MetaType baseMetaType; if (baseType.IsClass && baseType.GetCustomAttribute <DataContractAttribute>() == null && baseType.GetCustomAttribute <ProtoContractAttribute>() == null && model.GetTypes().OfType <MetaType>().All(a => a.Type != baseType)) { baseMetaType = model.Add(baseType, true); void ApplyImplicitFields(BindingFlags bindingFlags) { var fields = baseType .GetProperties(bindingFlags | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Cast <MemberInfo>() .Concat(baseType.GetFields( bindingFlags | BindingFlags.Instance | BindingFlags.DeclaredOnly)).ToList(); if (fields.Any(a => a.GetCustomAttribute <DataMemberAttribute>() != null || a.GetCustomAttribute <ProtoMemberAttribute>() != null)) { return; } var fieldNumber = 1; foreach (var name in fields.Where(x => x.GetCustomAttribute <IgnoreDataMemberAttribute>() == null && x.GetCustomAttribute <ProtoIgnoreAttribute>() == null && x.GetCustomAttribute <CompilerGeneratedAttribute>() == null) .Select(a => a.Name)) { baseMetaType.Add(fieldNumber++, name); } } switch (implicitFields) { case ImplicitFields.AllPublic: ApplyImplicitFields(BindingFlags.Public); break; case ImplicitFields.AllFields: ApplyImplicitFields(BindingFlags.Public | BindingFlags.NonPublic); break; case ImplicitFields.None: // Do noting break; } } else { baseMetaType = model.Add(baseType, true); } var rootMetaType = baseMetaType; while (rootMetaType.BaseType != null) { rootMetaType = rootMetaType.BaseType; } void ValidateMetaTypes(MetaType mt) { if (mt.HasSubtypes) { if (mt.GetSubtypes().Any(a => a.FieldNumber == attr.FieldNumber)) { throw new InvalidDataException( $"Cannot assign field number '{attr.FieldNumber}' for '{type.FullName}' on '{baseType.FullName}'. It's already being assigned to '{mt.Type.FullName}' in the hierarchy."); } foreach (var en in mt.GetSubtypes()) { ValidateMetaTypes(en.DerivedType); } } } ValidateMetaTypes(rootMetaType); baseMetaType.AddSubType(attr.FieldNumber, type); } }); }
public void TypeModel_Table_InternalSetter() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(InternalSetter))); }
/// <summary> /// Creates a new instance from a protocol-buffer stream that has a length-prefix /// on data (to assist with network IO). /// </summary> /// <typeparam name="T">The type to be created.</typeparam> /// <param name="source">The binary stream to apply to the new instance (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <param name="fieldNumber">The expected tag of the item (only used with base-128 prefix style).</param> /// <returns>A new, initialized instance.</returns> public static T DeserializeWithLengthPrefix <T>(Stream source, PrefixStyle style, int fieldNumber) { RuntimeTypeModel model = RuntimeTypeModel.Default; return((T)model.DeserializeWithLengthPrefix(source, null, model.MapType(typeof(T)), style, fieldNumber)); }
public void TypeModel_Struct_InternalAccess() { Assert.ThrowsException <InvalidFlatBufferDefinitionException>(() => RuntimeTypeModel.CreateFrom(typeof(InternalAccessStruct <byte>))); }