public Type GetPropertyType(String propertyName)
{
RevisionPropertyTypeDesc desc = _propertyDesc.Get(propertyName);
if (desc != null)
{
if (desc.PropertyType is Type)
{
return((Type)desc.PropertyType);
}
return(null);
}
// dynamic property names note allowed
if (propertyName.IndexOf('?') != -1)
{
return(null);
}
// see if this is a nested property
int index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
return(null);
}
// Map event types allow 2 types of properties inside:
// - a property that is a Java object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// Take apart the nested property into a map key and a nested value class property name
String propertyMap = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
String propertyNested = propertyName.Substring(index + 1);
desc = _propertyDesc.Get(propertyMap);
if (desc == null)
{
return(null); // prefix not a known property
}
else if (desc.PropertyType is Type)
{
Type simpleClass = (Type)desc.PropertyType;
EventType nestedEventType = _eventAdapterService.AddBeanType(simpleClass.FullName, simpleClass, false, false, false);
return(nestedEventType.GetPropertyType(propertyNested));
}
else
{
return(null);
}
}
public PropertyResolutionDescriptor ResolveByStreamAndPropName(String streamAndPropertyName, bool obtainFragment)
{
if (streamAndPropertyName == null)
{
throw new ArgumentException("Null stream and property name");
}
PropertyResolutionDescriptor desc;
try
{
// first try to resolve as a property name
desc = FindByPropertyName(streamAndPropertyName, obtainFragment);
}
catch (PropertyNotFoundException ex)
{
// Attempt to resolve by extracting a stream name
var index = ASTUtil.UnescapedIndexOfDot(streamAndPropertyName);
if (index == -1)
{
throw;
}
var streamName = streamAndPropertyName.Substring(0, index);
var propertyName = streamAndPropertyName.Substring(index + 1);
try
{
// try to resolve a stream and property name
desc = FindByStreamAndEngineName(propertyName, streamName, false, obtainFragment);
}
catch (StreamNotFoundException)
{
// Consider the engine URI as a further prefix
var propertyNoEnginePair = GetIsEngineQualified(propertyName, streamName);
if (propertyNoEnginePair == null)
{
throw ex;
}
try
{
return(FindByStreamNameOnly(propertyNoEnginePair.First, propertyNoEnginePair.Second, false, obtainFragment));
}
catch (StreamNotFoundException)
{
throw ex;
}
}
return(desc);
}
return(desc);
}
private Pair <String, String> GetIsEngineQualified(String propertyName, String streamName)
{
// If still not found, test for the stream name to contain the engine URI
if (!streamName.Equals(_engineURIQualifier))
{
return(null);
}
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
return(null);
}
var streamNameNoEngine = propertyName.Substring(0, index);
var propertyNameNoEngine = propertyName.Substring(index + 1);
return(new Pair <String, String>(propertyNameNoEngine, streamNameNoEngine));
}
private Type DoResolvePropertyType(String propertyExpression, bool allowSimpleProperties)
{
// see if this is an indexed property
int index = ASTUtil.UnescapedIndexOfDot(propertyExpression);
if ((!allowSimpleProperties) && (index == -1))
{
// parse, can be an indexed property
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
if (!property.IsDynamic)
{
if (!(property is IndexedProperty))
{
return(null);
}
var indexedProp = (IndexedProperty)property;
EventPropertyDescriptor descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic);
if (descriptor == null)
{
return(null);
}
return(descriptor.PropertyType);
}
}
Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
if (prop.IsDynamic)
{
return(typeof(XmlNode));
}
SchemaItem item = prop.GetPropertyTypeSchema(_schemaModelRoot, EventAdapterService);
if (item == null)
{
return(null);
}
return(SchemaUtil.ToReturnType(item));
}
public EventPropertyGetterSPI GetGetterSPI(string propertyName)
{
var desc = _propertyDesc.Get(propertyName);
if (desc != null)
{
return(desc.RevisionGetter);
}
// dynamic property names note allowed
if (propertyName.IndexOf('?') != -1)
{
return(null);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (prop is SimpleProperty)
{
// there is no such property since it wasn't found earlier
return(null);
}
string atomic = null;
if (prop is IndexedProperty)
{
var indexedprop = (IndexedProperty)prop;
atomic = indexedprop.PropertyNameAtomic;
}
if (prop is MappedProperty)
{
var indexedprop = (MappedProperty)prop;
atomic = indexedprop.PropertyNameAtomic;
}
desc = _propertyDesc.Get(atomic);
if (desc == null)
{
return(null);
}
if (!(desc.PropertyType is Type))
{
return(null);
}
var nestedClass = (Type)desc.PropertyType;
var complexProperty = (BeanEventType)_eventAdapterService.AddBeanType(nestedClass.GetDefaultTypeName(), nestedClass, false, false, false);
return(prop.GetGetter(complexProperty, _eventAdapterService));
}
// Map event types allow 2 types of properties inside:
// - a property that is a Java object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// 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);
desc = _propertyDesc.Get(propertyMap);
if (desc == null)
{
return(null); // prefix not a known property
}
// only nested classes supported for revision event types since deep property information not currently exposed by EventType
if (desc.PropertyType is Type)
{
// ask the nested class to resolve the property
var simpleClass = (Type)desc.PropertyType;
var nestedEventType = (EventTypeSPI)_eventAdapterService.AddBeanType(
simpleClass.Name, simpleClass, false, false, false);
var nestedGetter = nestedEventType.GetGetterSPI(propertyNested);
if (nestedGetter == null)
{
return(null);
}
// construct getter for nested property
return(new RevisionNestedPropertyGetter(desc.RevisionGetter, nestedGetter, _eventAdapterService));
}
else
{
return(null);
}
}
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);
}
}
private EventPropertyGetter DoResolvePropertyGetter(String propertyExpression, bool allowSimpleProperties)
{
EventPropertyGetter getter = _propertyGetterCache.Get(propertyExpression);
if (getter != null)
{
return(getter);
}
if (!allowSimpleProperties)
{
// see if this is an indexed property
int index = ASTUtil.UnescapedIndexOfDot(propertyExpression);
if (index == -1)
{
// parse, can be an indexed property
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
if (!property.IsDynamic)
{
if (!(property is IndexedProperty))
{
return(null);
}
var indexedProp = (IndexedProperty)property;
getter = PropertyGetters.Get(indexedProp.PropertyNameAtomic);
if (null == getter)
{
return(null);
}
EventPropertyDescriptor descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic);
if (descriptor == null)
{
return(null);
}
if (!descriptor.IsIndexed)
{
return(null);
}
if (descriptor.PropertyType == typeof(XmlNodeList))
{
FragmentFactory fragmentFactory = new FragmentFactoryDOMGetter(
EventAdapterService, this, indexedProp.PropertyNameAtomic);
return(new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory));
}
if (descriptor.PropertyType == typeof(string))
{
FragmentFactory fragmentFactory = new FragmentFactoryDOMGetter(
EventAdapterService, this, indexedProp.PropertyNameAtomic);
return(new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory));
}
}
}
}
if (!_isPropertyExpressionXPath)
{
Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
bool isDynamic = prop.IsDynamic;
if (!isDynamic)
{
SchemaItem item = prop.GetPropertyTypeSchema(_schemaModelRoot, EventAdapterService);
if (item == null)
{
return(null);
}
getter = prop.GetGetterDOM(_schemaModelRoot, EventAdapterService, this, propertyExpression);
if (getter == null)
{
return(null);
}
Type returnType = SchemaUtil.ToReturnType(item);
if ((returnType != typeof(XmlNode)) && (returnType != typeof(XmlNodeList)))
{
if (!returnType.IsArray)
{
getter = new DOMConvertingGetter(propertyExpression, (DOMPropertyGetter)getter, returnType);
}
else
{
getter = new DOMConvertingArrayGetter((DOMPropertyGetter)getter, returnType.GetElementType());
}
}
}
else
{
return(prop.GetGetterDOM());
}
}
else
{
bool allowFragments = !ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr;
getter = SchemaXMLPropertyParser.GetXPathResolution(
propertyExpression,
NamespaceContext,
RootElementName,
_rootElementNamespace,
_schemaModel,
EventAdapterService,
this,
allowFragments,
ConfigurationEventTypeXMLDOM.DefaultNamespace);
}
_propertyGetterCache.Put(propertyExpression, getter);
return(getter);
}
public static EventPropertyGetter GetGetter(
Schema avroSchema,
Dictionary <string, EventPropertyGetter> propertyGetterCache,
IDictionary <string, PropertySetDescriptorItem> propertyDescriptors,
string propertyName,
bool addToCache,
EventAdapterService eventAdapterService)
{
var getter = propertyGetterCache.Get(propertyName);
if (getter != null)
{
return(getter);
}
var unescapePropName = ASTUtil.UnescapeDot(propertyName);
var item = propertyDescriptors.Get(unescapePropName);
if (item != null)
{
getter = item.PropertyGetter;
MayAddToGetterCache(propertyName, propertyGetterCache, getter, true);
return(getter);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (prop is IndexedProperty)
{
var indexedProp = (IndexedProperty)prop;
Field field = avroSchema.GetField(prop.PropertyNameAtomic);
if (field == null)
{
return(null);
}
switch (field.Schema.Tag)
{
case Schema.Type.Array:
var fragmentEventType = AvroFragmentTypeUtil.GetFragmentEventTypeForField(
field.Schema, eventAdapterService);
getter = new AvroEventBeanGetterIndexed(
field, indexedProp.Index,
fragmentEventType == null ? null : fragmentEventType.FragmentType, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
case Schema.Type.String:
getter = new AvroEventBeanGetterStringIndexed(field, indexedProp.Index);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
default:
return(null);
}
}
else if (prop is MappedProperty)
{
var mappedProp = (MappedProperty)prop;
Field field = avroSchema.GetField(prop.PropertyNameAtomic);
if (field == null || field.Schema.Tag != Schema.Type.Map)
{
return(null);
}
getter = new AvroEventBeanGetterMapped(field, mappedProp.Key);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
if (prop is DynamicIndexedProperty)
{
var dynamicIndexedProp = (DynamicIndexedProperty)prop;
getter = new AvroEventBeanGetterIndexedDynamic(prop.PropertyNameAtomic, dynamicIndexedProp.Index);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
if (prop is DynamicMappedProperty)
{
var dynamicMappedProp = (DynamicMappedProperty)prop;
getter = new AvroEventBeanGetterMappedDynamic(prop.PropertyNameAtomic, dynamicMappedProp.Key);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
else if (prop is DynamicSimpleProperty)
{
getter = new AvroEventBeanGetterSimpleDynamic(prop.PropertyNameAtomic);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
return(null); // simple property already cached
}
// Take apart the nested property into a map key and a nested value class property name
var propertyTop = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
var propertyNested = propertyName.Substring(index + 1);
var isRootedDynamic = false;
// If the property is dynamic, remove the ? since the property type is defined without
if (propertyTop.EndsWith("?"))
{
propertyTop = propertyTop.Substring(0, propertyTop.Length - 1);
isRootedDynamic = true;
}
var propTop = PropertyParser.ParseAndWalkLaxToSimple(propertyTop);
Field fieldTop = avroSchema.GetField(propTop.PropertyNameAtomic);
// field is known and is a record
if (fieldTop != null && fieldTop.Schema.Tag == Schema.Type.Record && propTop is SimpleProperty)
{
var factory = new GetterNestedFactoryRootedSimple(eventAdapterService, fieldTop);
var property = PropertyParser.ParseAndWalk(propertyNested, isRootedDynamic);
getter = PropertyGetterNested(factory, fieldTop.Schema, property, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
// field is known and is a record
if (fieldTop != null && fieldTop.Schema.Tag == Schema.Type.Array && propTop is IndexedProperty)
{
var factory = new GetterNestedFactoryRootedIndexed(
eventAdapterService, fieldTop, ((IndexedProperty)propTop).Index);
var property = PropertyParser.ParseAndWalk(propertyNested, isRootedDynamic);
getter = PropertyGetterNested(factory, fieldTop.Schema.GetElementType(), property, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
// field is not known or is not a record
if (!isRootedDynamic)
{
return(null);
}
var propertyX = PropertyParser.ParseAndWalk(propertyNested, true);
var innerGetter = GetDynamicGetter(propertyX);
getter = new AvroEventBeanGetterNestedDynamicPoly(propertyTop, innerGetter);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
