public EventPropertyGetterSPI GetGetterIndexedEntryEventBeanArrayElement(
string propertyNameAtomic,
int index,
EventPropertyGetterSPI nestedGetter)
{
throw MakeIllegalState();
}
public EventPropertyGetterSPI GetGetterIndexedEntryEventBeanArrayElement(
string propertyNameAtomic,
int index,
EventPropertyGetterSPI nestedGetter)
{
return new MapEventBeanArrayIndexedElementPropertyGetter(propertyNameAtomic, index, nestedGetter);
}
public virtual EventPropertyGetter GetGetter(string propertyName)
{
if (!_eventAdapterService.EngineImportService.IsCodegenEventPropertyGetters)
{
return(GetGetterSPI(propertyName));
}
if (_propertyGetterCodegeneratedCache == null)
{
_propertyGetterCodegeneratedCache = new Dictionary <string, EventPropertyGetter>();
}
EventPropertyGetter getter = _propertyGetterCodegeneratedCache.Get(propertyName);
if (getter != null)
{
return(getter);
}
EventPropertyGetterSPI getterSPI = GetGetterSPI(propertyName);
if (getterSPI == null)
{
return(null);
}
EventPropertyGetter getterCode = _eventAdapterService.EngineImportService.CodegenGetter(getterSPI, propertyName);
_propertyGetterCodegeneratedCache.Put(propertyName, getterCode);
return(getterCode);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="propertyIndex">the property to look at</param>
/// <param name="eventBeanEntryGetter">the getter for the map entry</param>
public ObjectArrayEventBeanEntryPropertyGetter(
int propertyIndex,
EventPropertyGetterSPI eventBeanEntryGetter)
{
this.propertyIndex = propertyIndex;
this.eventBeanEntryGetter = eventBeanEntryGetter;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="revisionGetter">getter for revision value</param>
/// <param name="nestedGetter">getter to apply to revision value</param>
/// <param name="eventAdapterService">for handling object types</param>
public RevisionNestedPropertyGetter(EventPropertyGetterSPI revisionGetter, EventPropertyGetterSPI nestedGetter,
EventAdapterService eventAdapterService)
{
_revisionGetter = revisionGetter;
_eventAdapterService = eventAdapterService;
_nestedGetter = nestedGetter;
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (validationContext.ContextDescriptor == null) {
throw new ExprValidationException(
"Context property '" + PropertyName + "' cannot be used in the expression as provided");
}
var eventType = (EventTypeSPI) validationContext.ContextDescriptor.ContextPropertyRegistry.ContextEventType;
if (eventType == null) {
throw new ExprValidationException(
"Context property '" + PropertyName + "' cannot be used in the expression as provided");
}
getter = eventType.GetGetterSPI(PropertyName);
if (getter == null) {
throw new ExprValidationException(
"Context property '" +
PropertyName +
"' is not a known property, known properties are " +
eventType.PropertyNames.RenderAny());
}
Type = eventType.GetPropertyType(PropertyName).GetBoxedType();
return null;
}
public FilterForEvalContextPropDoubleForge(
EventPropertyGetterSPI getter,
string propertyName)
{
_getter = getter;
_propertyName = propertyName;
}
public ExprDotForgeProperty(
EventPropertyGetterSPI getter,
EPType returnType)
{
this.getter = getter;
this.returnType = returnType;
}
public ExprIdentNodeFragmentTypeEnumerationForge(string propertyName, int streamId, EventType fragmentEventType, EventPropertyGetterSPI getterSpi)
{
_propertyName = propertyName;
_streamId = streamId;
_fragmentEventType = fragmentEventType;
_getterSpi = getterSpi;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="propertyMap">the property to look at</param>
/// <param name="eventBeanEntryGetter">the getter for the map entry</param>
public MapEventBeanEntryPropertyGetter(
string propertyMap,
EventPropertyGetterSPI eventBeanEntryGetter)
{
this.propertyMap = propertyMap;
this.eventBeanEntryGetter = eventBeanEntryGetter;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="propertyName">property name</param>
/// <param name="index">array index</param>
/// <param name="nestedGetter">nested getter</param>
public MapEventBeanArrayIndexedElementPropertyGetter(string propertyName, int index,
EventPropertyGetterSPI nestedGetter)
{
this._propertyName = propertyName;
this._index = index;
this._nestedGetter = nestedGetter;
}
public SelectEvalStreamWUnderlying(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard,
IList<SelectExprStreamDesc> unnamedStreams,
bool singleStreamWrapper,
bool underlyingIsFragmentEvent,
int underlyingStreamNumber,
EventPropertyGetterSPI underlyingPropertyEventGetter,
ExprForge underlyingExprForge,
TableMetaData tableMetadata,
EventType[] eventTypes)
: base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard)
{
wrapperEventType = (WrapperEventType) resultEventType;
this.unnamedStreams = unnamedStreams;
this.singleStreamWrapper = singleStreamWrapper;
this.underlyingIsFragmentEvent = underlyingIsFragmentEvent;
this.underlyingStreamNumber = underlyingStreamNumber;
this.underlyingPropertyEventGetter = underlyingPropertyEventGetter;
this.underlyingExprForge = underlyingExprForge;
this.tableMetadata = tableMetadata;
this.eventTypes = eventTypes;
}
public ExprDotForgePropertyFragment(
EventPropertyGetterSPI getter,
EPType returnType)
{
_getter = getter;
_returnType = returnType;
}
public EventPropertyGetterSPI GetGetterNestedEventBean(
string propertyName,
EventPropertyGetterSPI nestedGetter)
{
var index = GetAssertIndex(propertyName);
return new ObjectArrayEventBeanEntryPropertyGetter(index, nestedGetter);
}
public PropertyDotNonLambdaFragmentForge(
int streamId,
EventPropertyGetterSPI getter)
{
this.streamId = streamId;
this.getter = getter;
}
public EventPropertyGetterSPI GetGetterIndexedEntryEventBeanArrayElement(
string propertyNameAtomic,
int index,
EventPropertyGetterSPI nestedGetter)
{
var propertyIndex = GetAssertIndex(propertyNameAtomic);
return new ObjectArrayEventBeanArrayIndexedElementPropertyGetter(propertyIndex, index, nestedGetter);
}
public WrapperMapPropertyGetter(WrapperEventType wrapperEventType, EventAdapterService eventAdapterService,
MapEventType underlyingMapType, EventPropertyGetterSPI mapGetter)
{
_wrapperEventType = wrapperEventType;
_eventAdapterService = eventAdapterService;
_underlyingMapType = underlyingMapType;
_mapGetter = mapGetter;
}
public ExprDotForgePropertyArray(EventPropertyGetterSPI getter, EPType returnType, ExprNode indexExpression, Type arrayType, string propertyName)
{
_getter = getter;
_returnType = returnType;
_indexExpression = indexExpression;
_arrayType = arrayType;
_propertyName = propertyName;
}
public static string From(
ICodegenContext context,
Type expectedUnderlyingType,
EventPropertyGetterSPI innerGetter,
AccessType accessType,
Type generator)
{
var block = context.AddMethod(accessType == AccessType.EXISTS ? typeof(bool) : typeof(object),
typeof(object), "value", generator)
.IfNotInstanceOf("value", expectedUnderlyingType)
.IfInstanceOf("value", typeof(EventBean))
.DeclareVarWCast(typeof(EventBean), "bean", "value");
switch (accessType)
{
case AccessType.GET:
block = block.BlockReturn(innerGetter.CodegenEventBeanGet(Ref("bean"), context));
break;
case AccessType.EXISTS:
block = block.BlockReturn(innerGetter.CodegenEventBeanExists(Ref("bean"), context));
break;
case AccessType.FRAGMENT:
block = block.BlockReturn(innerGetter.CodegenEventBeanFragment(Ref("bean"), context));
break;
default:
throw new UnsupportedOperationException("Invalid access type " + accessType);
}
block = block.BlockReturn(Constant(accessType == AccessType.EXISTS ? (object)false : null));
ICodegenExpression expression;
switch (accessType)
{
case AccessType.GET:
expression = innerGetter.CodegenUnderlyingGet(Cast(
expectedUnderlyingType, Ref("value")), context);
break;
case AccessType.EXISTS:
expression = innerGetter.CodegenUnderlyingExists(Cast(
expectedUnderlyingType, Ref("value")), context);
break;
case AccessType.FRAGMENT:
expression = innerGetter.CodegenUnderlyingFragment(
Cast(expectedUnderlyingType, Ref("value")), context);
break;
default:
throw new UnsupportedOperationException("Invalid access type " + accessType);
}
return(block.MethodReturn(expression));
}
public ExprEvaluatorStreamDTPropFragment(
int streamId,
EventPropertyGetterSPI getterFragment,
EventPropertyGetterSPI getterTimestamp)
{
this.streamId = streamId;
this.getterFragment = getterFragment;
this.getterTimestamp = getterTimestamp;
}
public PropertyDotEventSingleForge(
int streamId,
EventType fragmentType,
EventPropertyGetterSPI getter)
{
this.streamId = streamId;
this.fragmentType = fragmentType;
this.getter = getter;
}
public PropertyDotNonLambdaForge(
int streamId,
EventPropertyGetterSPI getter,
Type returnType)
{
this.streamId = streamId;
this.getter = getter;
EvaluationType = returnType;
}
public SelectExprProcessorEvalByGetterFragmentAvroArray(
int streamNum,
EventPropertyGetterSPI getter,
Type returnType)
{
_streamNum = streamNum;
_getter = getter;
_returnType = returnType;
}
public ExprEvalByGetter(
int streamNum,
EventPropertyGetterSPI getter,
Type returnType)
{
_streamNum = streamNum;
_getter = getter;
EvaluationType = returnType;
}
public ExprEvaluatorStreamDTProp(
int streamId,
EventPropertyGetterSPI getter,
Type getterReturnTypeBoxed)
{
this.streamId = streamId;
this.getter = getter;
EvaluationType = getterReturnTypeBoxed;
}
public QueryGraphValueEntryHashKeyedForgeProp(
ExprNode keyExpr,
string keyProperty,
EventPropertyGetterSPI eventPropertyGetter)
: base(keyExpr, true)
{
KeyProperty = keyProperty;
EventPropertyGetter = eventPropertyGetter;
}
public ExprContextPropertyNodeFragmentEnumerationForge(
string propertyName,
EventType fragmentEventType,
EventPropertyGetterSPI getterSpi)
{
_propertyName = propertyName;
_fragmentEventType = fragmentEventType;
_getterSpi = getterSpi;
}
public PropertyDotNonLambdaFragmentForge(
int streamId,
EventPropertyGetterSPI getter,
bool array)
{
this.streamId = streamId;
this.getter = getter;
this.array = array;
}
public ExprIdentNodeEvaluatorContext(
int streamNum,
Type resultType,
EventPropertyGetterSPI getter)
{
this.streamNum = streamNum;
this.resultType = resultType;
this.getter = getter;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="getter">property getter returning the parent node</param>
/// <param name="index">to get item at</param>
/// <param name="fragmentFactory">for creating fragments, or null if not creating fragments</param>
public XPathPropertyArrayItemGetter(
EventPropertyGetterSPI getter,
int index,
FragmentFactorySPI fragmentFactory)
{
this.getter = getter;
this.index = index;
this.fragmentFactory = fragmentFactory;
}
