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;
}
