public EventTypeCollectorImpl( IContainer container, IDictionary<string, EventType> moduleEventTypes, BeanEventTypeFactory beanEventTypeFactory, ClassLoader classLoader, EventTypeFactory eventTypeFactory, BeanEventTypeStemService beanEventTypeStemService, EventTypeNameResolver eventTypeNameResolver, XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory, EventTypeAvroHandler eventTypeAvroHandler, EventBeanTypedEventFactory eventBeanTypedEventFactory, ImportService importService) { _container = container; _moduleEventTypes = moduleEventTypes; _beanEventTypeFactory = beanEventTypeFactory; _classLoader = classLoader; _eventTypeFactory = eventTypeFactory; _beanEventTypeStemService = beanEventTypeStemService; _eventTypeNameResolver = eventTypeNameResolver; _xmlFragmentEventTypeFactory = xmlFragmentEventTypeFactory; _eventTypeAvroHandler = eventTypeAvroHandler; _eventBeanTypedEventFactory = eventBeanTypedEventFactory; _importService = importService; }
public EventType CreateXMLType( EventTypeMetadata metadata, ConfigurationCommonEventTypeXMLDOM detail, SchemaModel schemaModel, string representsFragmentOfProperty, string representsOriginalTypeName, BeanEventTypeFactory beanEventTypeFactory, XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory, EventTypeNameResolver eventTypeNameResolver) { if (metadata.IsPropertyAgnostic) { return new SimpleXMLEventType( metadata, detail, beanEventTypeFactory.EventBeanTypedEventFactory, eventTypeNameResolver, xmlFragmentEventTypeFactory); } return new SchemaXMLEventType( metadata, detail, schemaModel, representsFragmentOfProperty, representsOriginalTypeName, beanEventTypeFactory.EventBeanTypedEventFactory, eventTypeNameResolver, xmlFragmentEventTypeFactory); }
/// <summary> /// Make a wrapper type. /// A wrapper event type may indeed wrap another wrapper event type. This is so that a wrapper event bean can wrap /// another wrapper event bean. /// If there were unwrapped the nesting information such as what is the nested wrapper type and how they are nested /// would be lost. /// </summary> /// <param name="metadata">metadata</param> /// <param name="underlyingEventType">underlying event type</param> /// <param name="propertyTypesMayPrimitive">property types</param> /// <param name="eventBeanTypedEventFactory">factory for instances</param> /// <param name="beanEventTypeFactory">bean event type factory</param> /// <param name="eventTypeNameResolver">type name resolver</param> /// <returns>wrapper type</returns> public static WrapperEventType MakeWrapper( EventTypeMetadata metadata, EventType underlyingEventType, IDictionary<string, object> propertyTypesMayPrimitive, EventBeanTypedEventFactory eventBeanTypedEventFactory, BeanEventTypeFactory beanEventTypeFactory, EventTypeNameResolver eventTypeNameResolver) { // If we are wrapping an underlying type that is itself a wrapper, then this is a special case if (underlyingEventType is WrapperEventType underlyingWrapperType) { // the underlying type becomes the type already wrapped // properties are a superset of the wrapped properties and the additional properties underlyingEventType = underlyingWrapperType.UnderlyingEventType; var propertiesSuperset = new Dictionary<string, object>(); propertiesSuperset.PutAll(underlyingWrapperType.UnderlyingMapType.Types); propertiesSuperset.PutAll(propertyTypesMayPrimitive); propertyTypesMayPrimitive = propertiesSuperset; } IDictionary<string, object> verified = BaseNestableEventUtil.ResolvePropertyTypes( propertyTypesMayPrimitive, eventTypeNameResolver); return new WrapperEventType( metadata, underlyingEventType, verified, eventBeanTypedEventFactory, beanEventTypeFactory); }
public JsonEventType CreateJson( EventTypeMetadata metadata, IDictionary<String, Object> properties, string[] superTypes, string startTimestampPropertyName, string endTimestampPropertyName, BeanEventTypeFactory beanEventTypeFactory, EventTypeNameResolver eventTypeNameResolver, JsonEventTypeDetail detail) { var st = EventTypeUtility.GetSuperTypesDepthFirst(superTypes, EventUnderlyingType.JSON, eventTypeNameResolver); properties = BaseNestableEventUtil.ResolvePropertyTypes(properties, eventTypeNameResolver); var getterFactoryJson = new EventTypeNestableGetterFactoryJson(detail); // We use a null-stand-in class as the actual underlying class is provided later return new JsonEventType( metadata, properties, st.First, st.Second, startTimestampPropertyName, endTimestampPropertyName, getterFactoryJson, beanEventTypeFactory, detail, null, false); }
public XMLFragmentEventTypeFactory( BeanEventTypeFactory eventTypeFactory, EventTypeCompileTimeRegistry optionalCompileTimeRegistry, EventTypeNameResolver eventTypeNameResolver) { this.eventTypeFactory = eventTypeFactory; this.optionalCompileTimeRegistry = optionalCompileTimeRegistry; this.eventTypeNameResolver = eventTypeNameResolver; }
public FragmentFactoryXPathPredefinedGetter( EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeNameResolver eventTypeResolver, string eventTypeName, string propertyName) { this.eventBeanTypedEventFactory = eventBeanTypedEventFactory; this.eventTypeResolver = eventTypeResolver; this.eventTypeName = eventTypeName; this.propertyName = propertyName; }
private static void AddNestableMapType( string eventTypeName, IDictionary<string, object> propertyTypesMayHavePrimitive, ConfigurationCommonEventTypeMap optionalConfig, EventTypeRepositoryImpl repo, BeanEventTypeFactory beanEventTypeFactory, EventTypeNameResolver eventTypeNameResolver) { var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.APPLICATION, EventTypeApplicationType.MAP, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.NONBUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(eventTypeName), -1)); var propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(propertyTypesMayHavePrimitive); string[] superTypes = null; if (optionalConfig != null && optionalConfig.SuperTypes != null && !optionalConfig.SuperTypes.IsEmpty()) { superTypes = optionalConfig.SuperTypes.ToArray(); } var newEventType = beanEventTypeFactory.EventTypeFactory.CreateMap( metadata, propertyTypes, superTypes, optionalConfig?.StartTimestampPropertyName, optionalConfig?.EndTimestampPropertyName, beanEventTypeFactory, eventTypeNameResolver); var existingType = repo.GetTypeByName(eventTypeName); if (existingType != null) { // The existing type must be the same as the type createdStatement if (newEventType.EqualsCompareType(existingType) != null) { var message = newEventType.CompareEquals(existingType); throw new EPException( "Event type named '" + eventTypeName + "' has already been declared with differing column name or type information: " + message.Message, message); } return; } repo.AddType(newEventType); }
protected BaseConfigurableEventType( EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeMetadata metadata, Type underlyingType, EventTypeNameResolver eventTypeResolver, XMLFragmentEventTypeFactory xmlEventTypeFactory) { EventBeanTypedEventFactory = eventBeanTypedEventFactory; Metadata = metadata; UnderlyingType = underlyingType; EventTypeResolver = eventTypeResolver; XmlEventTypeFactory = xmlEventTypeFactory; }
private Schema Assemble( object value, Attribute[] annotations, ConfigurationCommonEventTypeMeta.AvroSettingsConfig avroSettings, EventTypeNameResolver eventTypeNameResolver) { var fields = new JArray(); AvroSchemaUtil.AssembleField("somefield", value, fields, annotations, avroSettings, eventTypeNameResolver, "stmtname", null); var schema = SchemaBuilder.Record("myrecord", fields); return(schema.GetField("somefield").Schema); }
public EventTypeResolverImpl( IDictionary<string, EventType> locals, PathRegistry<string, EventType> path, EventTypeNameResolver publics, BeanEventTypeFactoryPrivate beanEventTypeFactoryPrivate, EventSerdeFactory eventSerdeFactory) { this.locals = locals; this.path = path; this.publics = publics; this.beanEventTypeFactoryPrivate = beanEventTypeFactoryPrivate; this.eventSerdeFactory = eventSerdeFactory; }
public AvroSchemaEventType NewEventTypeFromNormalized( EventTypeMetadata metadata, EventTypeNameResolver eventTypeNameResolver, EventBeanTypedEventFactory eventBeanTypedEventFactory, IDictionary<string, object> properties, Attribute[] annotations, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] superTypes, ISet<EventType> deepSuperTypes, string statementName) { throw new UnsupportedOperationException(); }
public AvroSchemaEventType NewEventTypeFromNormalized( EventTypeMetadata metadata, EventTypeNameResolver eventTypeNameResolver, EventBeanTypedEventFactory eventAdapterService, IDictionary<string, object> properties, Attribute[] annotations, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] superTypes, ISet<EventType> deepSuperTypes, string statementName) { var assembler = new JArray(); var eventTypeName = metadata.Name; // add supertypes first so the positions are comparable var added = new HashSet<string>(); if (superTypes != null) { for (var i = 0; i < superTypes.Length; i++) { var superType = (AvroEventType) superTypes[i]; foreach (var field in superType.SchemaAvro.AsRecordSchema().Fields) { if (properties.ContainsKey(field.Name) || added.Contains(field.Name)) { continue; } added.Add(field.Name); assembler.Add(TypeBuilder.Field(field.Name, field.Schema)); //assembler.Name(field.Name).Type(field.Schema).NoDefault(); } } } foreach (var prop in properties) { if (!added.Contains(prop.Key)) { AvroSchemaUtil.AssembleField( prop.Key, prop.Value, assembler, annotations, _avroSettings, eventTypeNameResolver, statementName, _optionalTypeMapper); added.Add(prop.Key); } } var schema = SchemaBuilder.Record(eventTypeName, assembler); //Schema schema = assembler.EndRecord(); return MakeType(metadata, eventAdapterService, schema, optionalConfig, superTypes, deepSuperTypes); }
public static EventType Resolve( EventTypeMetadata metadata, EventTypeNameResolver publics, IDictionary<string, EventType> locals, PathRegistry<string, EventType> path) { EventTypeSPI type; // public can only see public if (metadata.AccessModifier == NameAccessModifier.PRECONFIGURED) { type = (EventTypeSPI) publics.GetTypeByName(metadata.Name); // for create-schema the type may be defined by the same module if (type == null) { type = (EventTypeSPI) locals.Get(metadata.Name); } } else if (metadata.AccessModifier == NameAccessModifier.PUBLIC || metadata.AccessModifier == NameAccessModifier.INTERNAL) { // path-visibility can be provided as local var local = locals.Get(metadata.Name); if (local != null) { if (local.Metadata.AccessModifier == NameAccessModifier.PUBLIC || local.Metadata.AccessModifier == NameAccessModifier.INTERNAL) { return (EventTypeSPI) local; } } try { var pair = path.GetAnyModuleExpectSingle( metadata.Name, Collections.SingletonSet(metadata.ModuleName)); type = (EventTypeSPI) pair?.First; } catch (PathException e) { throw new EPException(e.Message, e); } } else { type = (EventTypeSPI) locals.Get(metadata.Name); } if (type == null) { throw new EPException( "Failed to find event type '" + metadata.Name + "' among public types, modules-in-path or the current module itself"); } return type; }
public WrapperEventType CreateWrapper( EventTypeMetadata metadata, EventType underlying, IDictionary<string, object> properties, BeanEventTypeFactory beanEventTypeFactory, EventTypeNameResolver eventTypeNameResolver) { return WrapperEventTypeUtil.MakeWrapper( metadata, underlying, properties, beanEventTypeFactory.EventBeanTypedEventFactory, beanEventTypeFactory, eventTypeNameResolver); }
/// <summary> /// Ctor. /// </summary> /// <param name="configurationEventTypeXMLDOM">is the XML DOM configuration such as root element and schema names</param> /// <param name="metadata">event type metadata</param> /// <param name="eventBeanTypedEventFactory">for registration and lookup of types</param> /// <param name="xmlEventTypeFactory">xml type factory</param> /// <param name="eventTypeResolver">resolver</param> public BaseXMLEventType( EventTypeMetadata metadata, ConfigurationCommonEventTypeXMLDOM configurationEventTypeXMLDOM, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeNameResolver eventTypeResolver, XMLFragmentEventTypeFactory xmlEventTypeFactory) : base(eventBeanTypedEventFactory, metadata, typeof(XmlNode), eventTypeResolver, xmlEventTypeFactory) { RootElementName = configurationEventTypeXMLDOM.RootElementName; ConfigurationEventTypeXMLDOM = configurationEventTypeXMLDOM; if (configurationEventTypeXMLDOM.XPathFunctionResolver != null) { try { _functionResolver = TypeHelper.Instantiate<IXPathFunctionResolver>( configurationEventTypeXMLDOM.XPathFunctionResolver, ClassForNameProviderDefault.INSTANCE); } catch (ClassInstantiationException ex) { throw new ConfigurationException( "Error configuring XPath function resolver for XML type '" + configurationEventTypeXMLDOM.RootElementName + "' : " + ex.Message, ex); } } if (configurationEventTypeXMLDOM.XPathVariableResolver != null) { try { _variableResolver = TypeHelper.Instantiate<IXPathVariableResolver>( configurationEventTypeXMLDOM.XPathVariableResolver, ClassForNameProviderDefault.INSTANCE); } catch (ClassInstantiationException ex) { throw new ConfigurationException( "Error configuring XPath variable resolver for XML type '" + configurationEventTypeXMLDOM.RootElementName + "' : " + ex.Message, ex); } } }
public SimpleXMLEventType( EventTypeMetadata eventTypeMetadata, ConfigurationCommonEventTypeXMLDOM configurationEventTypeXMLDOM, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeNameResolver eventTypeResolver, XMLFragmentEventTypeFactory xmlEventTypeFactory) : base( eventTypeMetadata, configurationEventTypeXMLDOM, eventBeanTypedEventFactory, eventTypeResolver, xmlEventTypeFactory) { isResolvePropertiesAbsolute = configurationEventTypeXMLDOM.IsXPathResolvePropertiesAbsolute; propertyGetterCache = new Dictionary<string, EventPropertyGetterSPI>(); // Set of namespace context for XPath expressions var xPathNamespaceContext = new XPathNamespaceContext(); foreach (var entry in configurationEventTypeXMLDOM.NamespacePrefixes) { xPathNamespaceContext.AddNamespace(entry.Key, entry.Value); } if (configurationEventTypeXMLDOM.DefaultNamespace != null) { var defaultNamespace = configurationEventTypeXMLDOM.DefaultNamespace; xPathNamespaceContext.SetDefaultNamespace(defaultNamespace); // determine a default namespace prefix to use to construct XPath expressions from pure property names defaultNamespacePrefix = null; foreach (var entry in configurationEventTypeXMLDOM.NamespacePrefixes) { if (entry.Value.Equals(defaultNamespace)) { defaultNamespacePrefix = entry.Key; break; } } } NamespaceContext = xPathNamespaceContext; Initialize( configurationEventTypeXMLDOM.XPathProperties.Values, Collections.GetEmptyList<ExplicitPropertyDescriptor>()); }
public ObjectArrayEventType CreateObjectArray( EventTypeMetadata metadata, IDictionary<string, object> properties, string[] superTypes, string startTimestampPropertyName, string endTimestampPropertyName, BeanEventTypeFactory beanEventTypeFactory, EventTypeNameResolver eventTypeNameResolver) { var st = EventTypeUtility.GetSuperTypesDepthFirst( superTypes, EventUnderlyingType.OBJECTARRAY, eventTypeNameResolver); properties = BaseNestableEventUtil.ResolvePropertyTypes(properties, eventTypeNameResolver); return new ObjectArrayEventType( metadata, properties, st.First, st.Second, startTimestampPropertyName, endTimestampPropertyName, beanEventTypeFactory); }
private static Schema AssembleNestedSchema( MapEventType mapEventType, ConfigurationCommonEventTypeMeta.AvroSettingsConfig avroSettings, Attribute[] annotations, EventTypeNameResolver eventTypeNameResolver, string statementName, TypeRepresentationMapper optionalMapper) { var fields = new JArray(); foreach (var prop in mapEventType.Types) { AssembleField( prop.Key, prop.Value, fields, annotations, avroSettings, eventTypeNameResolver, statementName, optionalMapper); } return SchemaBuilder.Record(mapEventType.Name, fields); }
public SchemaXMLEventType( EventTypeMetadata eventTypeMetadata, ConfigurationCommonEventTypeXMLDOM config, SchemaModel schemaModel, string representsFragmentOfProperty, string representsOriginalTypeName, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeNameResolver eventTypeResolver, XMLFragmentEventTypeFactory xmlEventTypeFactory) : base( eventTypeMetadata, config, eventBeanTypedEventFactory, eventTypeResolver, xmlEventTypeFactory) { propertyGetterCache = new Dictionary<string, EventPropertyGetterSPI>(); SchemaModel = schemaModel; rootElementNamespace = config.RootElementNamespace; schemaModelRoot = SchemaUtil.FindRootElement(schemaModel, rootElementNamespace, RootElementName); isPropertyExpressionXPath = config.IsXPathPropertyExpr; RepresentsFragmentOfProperty = representsFragmentOfProperty; RepresentsOriginalTypeName = representsOriginalTypeName; // Set of namespace context for XPath expressions var ctx = new XPathNamespaceContext(); if (config.DefaultNamespace != null) { ctx.SetDefaultNamespace(config.DefaultNamespace); } foreach (var entry in config.NamespacePrefixes) { ctx.AddNamespace(entry.Key, entry.Value); } NamespaceContext = ctx; // add properties for the root element IList<ExplicitPropertyDescriptor> additionalSchemaProps = new List<ExplicitPropertyDescriptor>(); // Add a property for each complex child element foreach (SchemaElementComplex complex in schemaModelRoot.ComplexElements) { var propertyName = complex.Name; var returnType = typeof(XmlNode); Type propertyComponentType = null; if (complex.OptionalSimpleType != null) { returnType = SchemaUtil.ToReturnType(complex); if (returnType == typeof(string)) { propertyComponentType = typeof(char); } } if (complex.IsArray) { returnType = typeof(XmlNode[]); // We use Node[] for arrays and NodeList for XPath-Expressions returning Nodeset propertyComponentType = typeof(XmlNode); } var isFragment = false; if (ConfigurationEventTypeXMLDOM.IsAutoFragment && !ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr) { isFragment = CanFragment(complex); } var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, propertyComponentType, false, false, complex.IsArray, false, isFragment); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each simple child element foreach (var simple in schemaModelRoot.SimpleElements) { var propertyName = simple.Name; var returnType = SchemaUtil.ToReturnType(simple); var componentType = GenericExtensions.GetComponentType(returnType); var isIndexed = simple.IsArray || componentType != null; var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, componentType, false, false, isIndexed, false, false); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each attribute foreach (var attribute in schemaModelRoot.Attributes) { var propertyName = attribute.Name; var returnType = SchemaUtil.ToReturnType(attribute); var componentType = GenericExtensions.GetComponentType(returnType); var isIndexed = componentType != null; var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, componentType, false, false, isIndexed, false, false); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Finally add XPath properties as that may depend on the rootElementNamespace Initialize(config.XPathProperties.Values, additionalSchemaProps); }
public static void AssembleField( string propertyName, object propertyType, JArray assembler, Attribute[] annotations, ConfigurationCommonEventTypeMeta.AvroSettingsConfig avroSettings, EventTypeNameResolver eventTypeNameResolver, string statementName, TypeRepresentationMapper optionalMapper) { if (propertyName.Contains(".")) { throw new EPException( "Invalid property name as Avro does not allow dot '.' in field names (property '" + propertyName + "')"); } Schema schema = GetAnnotationSchema(propertyName, annotations); if (schema != null) { assembler.Add(TypeBuilder.Field(propertyName, schema)); // assembler.Name(propertyName).Type(schema).NoDefault(); return; } if (optionalMapper != null && propertyType is Type propertyTypeType) { var schemaResult = optionalMapper.Map( new TypeRepresentationMapperContext(propertyTypeType, propertyName, statementName)); if (schemaResult is JToken schemaAsJsonToken) { assembler.Add(TypeBuilder.Field(propertyName, schemaAsJsonToken)); return; } if (schemaResult is Schema schemaFromResult) { assembler.Add(TypeBuilder.Field(propertyName, schemaFromResult)); // assembler.Name(propertyName).Type(result).NoDefault(); return; } } if (propertyType == null) { assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.NullType())); // assembler.Name(propertyName).Type("null"); } else if (propertyType is string) { string propertyTypeName = propertyType.ToString(); bool isArray = EventTypeUtility.IsPropertyArray(propertyTypeName); if (isArray) { propertyTypeName = EventTypeUtility.GetPropertyRemoveArray(propertyTypeName); } // Add EventType itself as a property EventType eventType = eventTypeNameResolver.GetTypeByName(propertyTypeName); if (!(eventType is AvroEventType)) { throw new EPException( "Type definition encountered an unexpected property type name '" + propertyType + "' for property '" + propertyName + "', expected the name of a previously-declared Avro type"); } schema = ((AvroEventType) eventType).SchemaAvro; if (!isArray) { assembler.Add(TypeBuilder.Field(propertyName, schema)); } else { assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema))); } } else if (propertyType is EventType) { var eventType = (EventType) propertyType; CheckCompatibleType(eventType); if (eventType is AvroEventType) { schema = ((AvroEventType) eventType).SchemaAvro; assembler.Add(TypeBuilder.Field(propertyName, schema)); } else if (eventType is MapEventType) { var mapEventType = (MapEventType) eventType; var nestedSchema = AssembleNestedSchema( mapEventType, avroSettings, annotations, eventTypeNameResolver, statementName, optionalMapper); assembler.Add(TypeBuilder.Field(propertyName, nestedSchema)); } else { throw new IllegalStateException("Unrecognized event type " + eventType); } } else if (propertyType is EventType[]) { EventType eventType = ((EventType[]) propertyType)[0]; CheckCompatibleType(eventType); if (eventType is AvroEventType) { schema = ((AvroEventType) eventType).SchemaAvro; assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema))); } else if (eventType is MapEventType) { var mapEventType = (MapEventType) eventType; var nestedSchema = AssembleNestedSchema( mapEventType, avroSettings, annotations, eventTypeNameResolver, statementName, optionalMapper); assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(nestedSchema))); } else { throw new IllegalStateException("Unrecognized event type " + eventType); } } else if (propertyType is Type) { var propertyClass = (Type) propertyType; var propertyClassBoxed = propertyClass.GetBoxedType(); bool nullable = propertyClass == propertyClassBoxed; bool preferNonNull = avroSettings.IsEnableSchemaDefaultNonNull; if (propertyClassBoxed == typeof(bool?)) { AssemblePrimitive(nullable, REQ_BOOLEAN, OPT_BOOLEAN, assembler, propertyName, preferNonNull); } else if (propertyClassBoxed == typeof(int?) || propertyClassBoxed == typeof(byte?)) { AssemblePrimitive(nullable, REQ_INT, OPT_INT, assembler, propertyName, preferNonNull); } else if (propertyClassBoxed == typeof(long?)) { AssemblePrimitive(nullable, REQ_LONG, OPT_LONG, assembler, propertyName, preferNonNull); } else if (propertyClassBoxed == typeof(float?)) { AssemblePrimitive(nullable, REQ_FLOAT, OPT_FLOAT, assembler, propertyName, preferNonNull); } else if (propertyClassBoxed == typeof(double?)) { AssemblePrimitive(nullable, REQ_DOUBLE, OPT_DOUBLE, assembler, propertyName, preferNonNull); } else if (propertyClass == typeof(string)) { if (avroSettings.IsEnableNativeString) { if (preferNonNull) { assembler.Add( TypeBuilder.Field( propertyName, TypeBuilder.Primitive( "string", TypeBuilder.Property( AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)))); } else { assembler.Add( TypeBuilder.Field( propertyName, TypeBuilder.Union( TypeBuilder.NullType(), TypeBuilder.StringType( TypeBuilder.Property( AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE))))); } } else { AssemblePrimitive(nullable, REQ_STRING, OPT_STRING, assembler, propertyName, preferNonNull); } } else if (propertyClass == typeof(byte[])) { if (preferNonNull) { assembler.Add(TypeBuilder.RequiredBytes(propertyName)); } else { assembler.Add( TypeBuilder.Field( propertyName, TypeBuilder.Union( TypeBuilder.NullType(), TypeBuilder.BytesType()))); } } else if (propertyClass.IsArray) { var componentType = propertyClass.GetElementType(); var componentTypeBoxed = componentType.GetBoxedType(); var nullableElements = componentType == componentTypeBoxed; if (componentTypeBoxed == typeof(bool?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_BOOLEAN, ARRAY_OF_OPT_BOOLEAN, assembler, propertyName, preferNonNull); } else if (componentTypeBoxed == typeof(int?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull); } else if (componentTypeBoxed == typeof(long?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_LONG, ARRAY_OF_OPT_LONG, assembler, propertyName, preferNonNull); } else if (componentTypeBoxed == typeof(float?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_FLOAT, ARRAY_OF_OPT_FLOAT, assembler, propertyName, preferNonNull); } else if (componentTypeBoxed == typeof(double?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_DOUBLE, ARRAY_OF_OPT_DOUBLE, assembler, propertyName, preferNonNull); } else if (componentTypeBoxed == typeof(byte?)) { AssembleArray( nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull); } else if (propertyClass == typeof(string[])) { JObject array; if (avroSettings.IsEnableNativeString) { array = TypeBuilder.Array( TypeBuilder.StringType( TypeBuilder.Property( AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE))); } else { array = TypeBuilder.Array(TypeBuilder.StringType()); } if (preferNonNull) { assembler.Add(TypeBuilder.Field(propertyName, array)); } else { assembler.Add( TypeBuilder.Field( propertyName, TypeBuilder.Union( TypeBuilder.NullType(), array))); } } else if (propertyClass.CanUnwrap<object>()) { } else { throw MakeEPException(propertyName, propertyType); } } else if (propertyClass.IsGenericDictionary()) { JToken value; if (avroSettings.IsEnableNativeString) { value = TypeBuilder.StringType( TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)); } else { value = TypeBuilder.StringType(); } if (preferNonNull) { assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Map(value))); } else { assembler.Add( TypeBuilder.Field( propertyName, TypeBuilder.Union( TypeBuilder.NullType(), TypeBuilder.Map(value)))); } } else if (propertyClass.IsGenericCollection()) { AssembleFieldForCollection( propertyName, propertyType, assembler, avroSettings, propertyClass, preferNonNull); } else { throw MakeEPException(propertyName, propertyType); } } else { throw MakeEPException(propertyName, propertyType); } }
public static LinkedHashMap<string, object> ResolvePropertyTypes( IDictionary<string, object> propertyTypes, EventTypeNameResolver eventTypeNameResolver) { var verified = new LinkedHashMap<string, object>(); foreach (var prop in propertyTypes) { var propertyName = prop.Key; var propertyType = prop.Value; if (propertyType is Type || propertyType is EventType || propertyType == null || propertyType is TypeBeanOrUnderlying) { verified.Put(propertyName, propertyType); continue; } if (propertyType is EventType[]) { var types = (EventType[]) propertyType; if (types.Length != 1 || types[0] == null) { throw new ArgumentException("Invalid null event type array"); } verified.Put(propertyName, propertyType); continue; } if (propertyType is TypeBeanOrUnderlying[]) { var types = (TypeBeanOrUnderlying[]) propertyType; if (types.Length != 1 || types[0] == null) { throw new ArgumentException("Invalid null event type array"); } verified.Put(propertyName, propertyType); continue; } if (propertyType is IDictionary<string, object>) { IDictionary<string, object> inner = ResolvePropertyTypes( (IDictionary<string, object>) propertyType, eventTypeNameResolver); verified.Put(propertyName, inner); continue; } if (!(propertyType is string propertyTypeName)) { throw MakeUnexpectedTypeException(propertyType.ToString(), propertyName); } var isArray = EventTypeUtility.IsPropertyArray(propertyTypeName); if (isArray) { propertyTypeName = EventTypeUtility.GetPropertyRemoveArray(propertyTypeName); } var eventType = eventTypeNameResolver.GetTypeByName(propertyTypeName); if (!(eventType is BaseNestableEventType) && !(eventType is BeanEventType)) { var clazz = TypeHelper.GetPrimitiveTypeForName(propertyTypeName); if (clazz != null) { verified.Put(propertyName, clazz); continue; } throw MakeUnexpectedTypeException(propertyTypeName, propertyName); } if (eventType is BaseNestableEventType) { var typeEntity = !isArray ? new TypeBeanOrUnderlying(eventType) : (object) new[] {new TypeBeanOrUnderlying(eventType)}; verified.Put(propertyName, typeEntity); continue; } var beanEventType = (BeanEventType) eventType; object type = !isArray ? beanEventType.UnderlyingType : TypeHelper.GetArrayType(beanEventType.UnderlyingType); verified.Put(propertyName, type); } return verified; }