private static Type ResolveClassForTypeName(
string type,
ImportService importService)
{
var isArray = false;
if (type != null && EventTypeUtility.IsPropertyArray(type)) {
isArray = true;
type = EventTypeUtility.GetPropertyRemoveArray(type);
}
if (type == null) {
throw new ConfigurationException("A null value has been provided for the type");
}
try {
var clazz = TypeHelper.GetTypeForSimpleName(type, importService.ClassForNameProvider);
if (clazz == null) {
return null;
}
if (isArray) {
clazz = clazz.MakeArrayType();
}
return clazz;
}
catch (TypeLoadException e) {
Log.Error($"Unable to load type \"{e.Message}\"", e);
return null;
}
}
private static Type ResolveClassForTypeName(
string type,
ImportService importService)
{
var isArray = false;
if (type != null && EventTypeUtility.IsPropertyArray(type)) {
isArray = true;
type = EventTypeUtility.GetPropertyRemoveArray(type);
}
if (type == null) {
throw new ConfigurationException("A null value has been provided for the type");
}
var clazz = TypeHelper.GetTypeForSimpleName(type, importService.ClassForNameProvider);
if (clazz == null) {
throw new ConfigurationException("The type '" + type + "' is not a recognized type");
}
if (isArray) {
clazz = clazz.MakeArrayType();
}
return clazz;
}
public override Type GetPropertyTypeMap(IDictionary <string, object> optionalMapPropTypes, EventAdapterService eventAdapterService)
{
// The simple, none-dynamic property needs a definition of the map contents else no property
if (optionalMapPropTypes == null)
{
return(null);
}
var def = optionalMapPropTypes.Get(PropertyNameAtomic);
if (def == null)
{
return(null);
}
if (def is Type)
{
return(((Type)def).GetBoxedType());
}
else if (def is IDictionary <string, object> )
{
return(typeof(IDictionary <string, object>));
}
else if (def is String)
{
String propertyName = def.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(propertyName);
if (isArray)
{
propertyName = EventTypeUtility.GetPropertyRemoveArray(propertyName);
}
var eventType = eventAdapterService.GetEventTypeByName(propertyName);
if (eventType is MapEventType)
{
if (isArray)
{
return(typeof(IDictionary <string, object>[]));
}
else
{
return(typeof(IDictionary <string, object>));
}
}
if (eventType is ObjectArrayEventType)
{
if (isArray)
{
return(typeof(Object[][]));
}
else
{
return(typeof(Object[]));
}
}
}
String message = "Nestable map type configuration encountered an unexpected value type of '"
+ def.GetType() + " for property '" + PropertyNameAtomic + "', expected Map or Class";
throw new PropertyAccessException(message);
}
private static Type ResolveTypeForTypeName(String type)
{
bool isArray = false;
if (type != null && EventTypeUtility.IsPropertyArray(type))
{
isArray = true;
type = EventTypeUtility.GetPropertyRemoveArray(type);
}
if (type == null)
{
throw new ConfigurationException("A null value has been provided for the type");
}
var clazz = TypeHelper.GetTypeForSimpleName(type);
if (clazz == null)
{
throw new ConfigurationException("The type '" + type + "' is not a recognized type");
}
if (isArray)
{
clazz = Array.CreateInstance(clazz, 0).GetType();
}
return(clazz);
}
public override ObjectArrayEventPropertyGetter GetGetterObjectArray(
IDictionary <string, int> indexPerProperty,
IDictionary <string, object> nestableTypes,
EventAdapterService eventAdapterService)
{
int propertyIndex;
if (!indexPerProperty.TryGetValue(PropertyNameAtomic, out propertyIndex))
{
return(null);
}
var type = nestableTypes.Get(PropertyNameAtomic);
if (type == null)
{
return(null);
}
if (type is string) // resolve a property that is a map event type
{
var nestedName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
var innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is MapEventType))
{
return(null);
}
if (!isArray)
{
return(null); // must be declared as an array to use an indexed notation
}
else
{
return(new ObjectArrayArrayPropertyGetter(propertyIndex, _index, eventAdapterService, innerType));
}
}
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray())
{
return(null);
}
var componentType = ((Type)type).GetElementType();
// its an array
return(new ObjectArrayArrayPonoEntryIndexedPropertyGetter(
propertyIndex, _index, eventAdapterService, componentType));
}
}
public override MapEventPropertyGetter GetGetterMap(DataMap optionalMapPropTypes, EventAdapterService eventAdapterService)
{
var type = optionalMapPropTypes.Get(PropertyNameAtomic);
if (type == null)
{
return(null);
}
if (type is string) // resolve a property that is a map event type
{
var nestedName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
var innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is MapEventType))
{
return(null);
}
if (!isArray)
{
return(null); // must be declared as an array to use an indexed notation
}
else
{
return(new MapArrayPropertyGetter(
PropertyNameAtomic, _index, eventAdapterService, innerType));
}
}
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
var componentType = ((Type)type).GetElementType();
// its an array
return(new MapArrayPonoEntryIndexedPropertyGetter(
PropertyNameAtomic, _index, eventAdapterService, componentType));
}
}
public override Type GetPropertyTypeMap(DataMap optionalMapPropTypes, EventAdapterService eventAdapterService)
{
var type = optionalMapPropTypes.Get(PropertyNameAtomic);
if (type == null)
{
return(null);
}
if (type is String) // resolve a property that is a map event type
{
var nestedName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
var innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is MapEventType))
{
return(null);
}
if (!isArray)
{
return(null); // must be declared as an index to use array notation
}
else
{
return(typeof(DataMap[]));
}
}
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
return(((Type)type).GetElementType().GetBoxedType());
}
}
internal static void AssembleField(
string propertyName,
Object propertyType,
JArray assembler,
Attribute[] annotations,
ConfigurationEngineDefaults.AvroSettings avroSettings,
EventAdapterService eventAdapterService,
string statementName,
string engineURI,
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)
{
var result = (Schema) optionalMapper.Map(
new TypeRepresentationMapperContext(
(Type) propertyType, propertyName, statementName, engineURI));
if (result != null)
{
assembler.Add(TypeBuilder.Field(propertyName, result));
// assembler.Name(propertyName).Type(result).NoDefault();
return;
}
}
if (propertyType == null)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Null()));
// 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 = eventAdapterService.GetEventTypeByName(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, eventAdapterService, statementName, engineURI,
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, eventAdapterService, statementName, engineURI,
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.Null(),
TypeBuilder.String(
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.Null(), TypeBuilder.Bytes())));
}
}
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.String(TypeBuilder.Property(
AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)));
}
else
{
array = TypeBuilder.Array(TypeBuilder.String());
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, array));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.Null(), array)));
}
}
else if (propertyClass.CanUnwrap<object>())
{
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
else if (propertyClass.IsGenericDictionary())
{
JToken value;
if (avroSettings.IsEnableNativeString)
{
value = TypeBuilder.String(
TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE));
}
else
{
value = TypeBuilder.String();
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Map(value)));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.Null(), 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 MapEventPropertyGetter GetGetterMap(Map optionalMapPropTypes, EventAdapterService eventAdapterService)
{
var getters = new List <EventPropertyGetter>();
var currentDictionary = optionalMapPropTypes;
int count = 0;
for (var it = Properties.EnumerateWithLookahead(); it.HasNext();)
{
count++;
Property property = it.Next();
// manufacture a getter for getting the item out of the map
EventPropertyGetter getter = property.GetGetterMap(currentDictionary, eventAdapterService);
if (getter == null)
{
return(null);
}
getters.Add(getter);
var @base = (PropertyBase)property;
var propertyName = @base.PropertyNameAtomic;
// For the next property if there is one, check how to property type is defined
if (!it.HasNext())
{
continue;
}
if (currentDictionary != null)
{
// check the type that this property will return
Object propertyReturnType = currentDictionary.Get(propertyName);
if (propertyReturnType == null)
{
currentDictionary = null;
}
if (propertyReturnType != null)
{
if (propertyReturnType is Map)
{
currentDictionary = (Map)propertyReturnType;
}
else if (ReferenceEquals(propertyReturnType, typeof(Map)))
{
currentDictionary = null;
}
else if (propertyReturnType is String)
{
String nestedName = propertyReturnType.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
EventType innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (innerType == null)
{
return(null);
}
String remainingProps = ToPropertyEPL(Properties, count);
EventPropertyGetter getterInner = innerType.GetGetter(remainingProps);
if (getterInner == null)
{
return(null);
}
getters.Add(getterInner);
break; // the single getter handles the rest
}
else if (propertyReturnType is EventType)
{
var innerType = (EventType)propertyReturnType;
var remainingProps = ToPropertyEPL(Properties, count);
var getterInner = innerType.GetGetter(remainingProps);
if (getterInner == null)
{
return(null);
}
getters.Add(getterInner);
break; // the single getter handles the rest
}
else
{
// treat the return type of the map property as an object
var returnType = (Type)propertyReturnType;
if (!returnType.IsArray)
{
BeanEventType beanType =
eventAdapterService.BeanEventTypeFactory.CreateBeanType(returnType.Name, returnType,
false, false, false);
String remainingProps = ToPropertyEPL(Properties, count);
EventPropertyGetter getterInner = beanType.GetGetter(remainingProps);
if (getterInner == null)
{
return(null);
}
getters.Add(getterInner);
break; // the single getter handles the rest
}
else
{
Type componentType = returnType.GetElementType();
BeanEventType beanType = eventAdapterService.BeanEventTypeFactory.CreateBeanType(
componentType.Name, componentType, false, false, false);
String remainingProps = ToPropertyEPL(Properties, count);
EventPropertyGetter getterInner = beanType.GetGetter(remainingProps);
if (getterInner == null)
{
return(null);
}
getters.Add(getterInner);
break; // the single pono getter handles the rest
}
}
}
}
}
var hasNonmapGetters = false;
for (int i = 0; i < getters.Count; i++)
{
if (!(getters[i] is MapEventPropertyGetter))
{
hasNonmapGetters = true;
}
}
if (!hasNonmapGetters)
{
return(new MapNestedPropertyGetterMapOnly(getters, eventAdapterService));
}
else
{
return(new MapNestedPropertyGetterMixedType(getters, eventAdapterService));
}
}
public Type GetPropertyTypeMap(Map optionalMapPropTypes, EventAdapterService eventAdapterService)
{
Map currentDictionary = optionalMapPropTypes;
int count = 0;
for (var it = Properties.EnumerateWithLookahead(); it.HasNext();)
{
count++;
var property = it.Next();
var propertyBase = (PropertyBase)property;
var propertyName = propertyBase.PropertyNameAtomic;
Object nestedType = null;
if (currentDictionary != null)
{
nestedType = currentDictionary.Get(propertyName);
}
if (nestedType == null)
{
if (property is DynamicProperty)
{
return(typeof(Object));
}
else
{
return(null);
}
}
if (!it.HasNext())
{
if (nestedType is Type)
{
return(((Type)nestedType).GetBoxedType());
}
if (nestedType is Map)
{
return(typeof(Map));
}
}
if (ReferenceEquals(nestedType, typeof(Map)))
{
return(typeof(Object));
}
if (nestedType is Type)
{
Type pocoType = (Type)nestedType;
if (!pocoType.IsArray)
{
BeanEventType beanType = eventAdapterService.BeanEventTypeFactory.CreateBeanType(pocoType.Name, pocoType, false, false, false);
String remainingProps = ToPropertyEPL(Properties, count);
return(beanType.GetPropertyType(remainingProps).GetBoxedType());
}
else if (property is IndexedProperty)
{
Type componentType = pocoType.GetElementType();
BeanEventType beanType = eventAdapterService.BeanEventTypeFactory.CreateBeanType(componentType.Name, componentType, false, false, false);
String remainingProps = ToPropertyEPL(Properties, count);
return(beanType.GetPropertyType(remainingProps).GetBoxedType());
}
}
if (nestedType is String) // property type is the name of a map event type
{
String nestedName = nestedType.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
EventType innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (innerType == null)
{
return(null);
}
String remainingProps = ToPropertyEPL(Properties, count);
return(innerType.GetPropertyType(remainingProps).GetBoxedType());
}
else if (nestedType is EventType) // property type is the name of a map event type
{
var innerType = (EventType)nestedType;
var remainingProps = ToPropertyEPL(Properties, count);
return(innerType.GetPropertyType(remainingProps).GetBoxedType());
}
else
{
if (!(nestedType is Map))
{
String message = "Nestable map type configuration encountered an unexpected value type of '"
+ nestedType.GetType() + " for property '" + propertyName + "', expected Class, typeof(Map) or IDictionary<String, Object> as value type";
throw new PropertyAccessException(message);
}
}
currentDictionary = (Map)nestedType;
}
throw new IllegalStateException("Unexpected end of nested property");
}
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;
}
public FragmentEventType GetFragmentType(String propertyName)
{
var item = _propertyItems.Get(propertyName);
if (item != null) // may contain null values
{
return(item.FragmentEventType);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
// dynamic simple property
if (propertyName.EndsWith("?"))
{
return(null);
}
// parse, can be an indexed property
var property = PropertyParser.ParseAndWalk(propertyName);
if (property is IndexedProperty)
{
var indexedProp = (IndexedProperty)property;
var type = NestableTypes.Get(indexedProp.PropertyNameAtomic);
if (type == null)
{
return(null);
}
else if (type is EventType[])
{
var eventType = ((EventType[])type)[0];
return(new FragmentEventType(eventType, false, false));
}
else if (type is String)
{
var propTypeName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(propTypeName);
if (!isArray)
{
return(null);
}
propTypeName = EventTypeUtility.GetPropertyRemoveArray(propTypeName);
EventType innerType = EventAdapterService.GetEventTypeByName(propTypeName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(new FragmentEventType(innerType, false, false)); // false since an index is present
}
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
// its an array
return(EventBeanUtility.CreateNativeFragmentType(((Type)type).GetElementType(), null, EventAdapterService));
}
else if (property is MappedProperty)
{
// No type information available for the inner event
return(null);
}
else
{
return(null);
}
}
// Map event types allow 2 types of properties inside:
// - a property that is a object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// The property getters therefore act on
// Take apart the nested property into a map key and a nested value class property name
var propertyMap = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
var propertyNested = propertyName.Substring(index + 1);
// If the property is dynamic, it cannot be a fragment
if (propertyMap.EndsWith("?"))
{
return(null);
}
var nestedType = NestableTypes.Get(propertyMap);
if (nestedType == null)
{
// parse, can be an indexed property
var property = PropertyParser.ParseAndWalk(propertyMap);
if (property is IndexedProperty)
{
var indexedProp = (IndexedProperty)property;
var type = NestableTypes.Get(indexedProp.PropertyNameAtomic);
if (type == null)
{
return(null);
}
// handle map-in-map case
if (type is String)
{
var propTypeName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(propTypeName);
if (isArray)
{
propTypeName = EventTypeUtility.GetPropertyRemoveArray(propTypeName);
}
EventType innerType = EventAdapterService.GetEventTypeByName(propTypeName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(innerType.GetFragmentType(propertyNested));
}
// handle eventtype[] in map
else if (type is EventType[])
{
var innerType = ((EventType[])type)[0];
return(innerType.GetFragmentType(propertyNested));
}
// handle array class in map case
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
var fragmentParent = EventBeanUtility.CreateNativeFragmentType(
(Type)type, null, EventAdapterService);
if (fragmentParent == null)
{
return(null);
}
return(fragmentParent.FragmentType.GetFragmentType(propertyNested));
}
}
else if (property is MappedProperty)
{
// No type information available for the property's map value
return(null);
}
else
{
return(null);
}
}
// If there is a map value in the map, return the Object value if this is a dynamic property
if (ReferenceEquals(nestedType, typeof(IDictionary <string, object>)))
{
return(null);
}
else if (nestedType is IDictionary <string, object> )
{
return(null);
}
else if (nestedType is Type)
{
var simpleClass = (Type)nestedType;
if (!TypeHelper.IsFragmentableType(simpleClass))
{
return(null);
}
EventType nestedEventType =
EventAdapterService.BeanEventTypeFactory.CreateBeanTypeDefaultName(simpleClass);
return(nestedEventType.GetFragmentType(propertyNested));
}
else if (nestedType is EventType)
{
var innerType = (EventType)nestedType;
return(innerType.GetFragmentType(propertyNested));
}
else if (nestedType is EventType[])
{
var innerType = (EventType[])nestedType;
return(innerType[0].GetFragmentType(propertyNested));
}
else if (nestedType is String)
{
var nestedName = nestedType.ToString();
var isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
var innerType = EventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(innerType.GetFragmentType(propertyNested));
}
else
{
var message = "Nestable map type configuration encountered an unexpected value type of '"
+ nestedType.GetType() + " for property '" + propertyName +
"', expected Class, typeof(Map) or IDictionary<String, Object> as value type";
throw new PropertyAccessException(message);
}
}