public Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
var result = new LinkedHashMap <object, ICollection <object> >();
var resultEvent = new ObjectArrayEventBean(new Object[1], _resultEventType);
var values = target;
foreach (Object next in values)
{
resultEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = resultEvent;
var key = InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
resultEvent.Properties[0] = next;
var entry = _secondExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
var value = result.Get(key);
if (value == null)
{
value = new List <object>();
result.Put(key, value);
}
value.Add(entry);
}
return(result);
}
public override View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
var builtinBean = new ObjectArrayEventBean(ExpressionViewOAFieldEnumExtensions.GetPrototypeOA(), BuiltinMapType);
var viewUpdatedCollection = agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory.GetOptPreviousExprRelativeAccess(agentInstanceViewFactoryContext);
return(new ExpressionBatchView(this, viewUpdatedCollection, ExpiryExpressionEvaluator, AggregationServiceFactoryDesc, builtinBean, VariableNames, agentInstanceViewFactoryContext));
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return Collections.GetEmptyMap<object, object>();
}
IDictionary<object, ICollection<object>> result = new LinkedHashMap<object, ICollection<object>>();
var values = (ICollection<object>) enumcoll;
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
foreach (var next in values) {
props[0] = next;
var key = _innerExpression.Evaluate(eventsLambda, isNewData, context);
var value = result.Get(key);
if (value == null) {
value = new List<object>();
result.Put(key, value);
}
value.Add(next);
}
return result;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
var agg =
new EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal(_forge.optionalMathContext);
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
var values = (ICollection<object>) enumcoll;
foreach (var next in values) {
props[0] = next;
var num = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (num == null) {
continue;
}
agg.Enter(num);
}
return agg.Value;
}
public override View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
var builtinBean = new ObjectArrayEventBean(ExpressionViewOAFieldEnumExtensions.GetPrototypeOA(), BuiltinMapType);
var randomAccess = ViewServiceHelper.GetOptPreviousExprRandomAccess(agentInstanceViewFactoryContext);
return(new ExpressionWindowView(this, randomAccess, ExpiryExpression.ExprEvaluator, AggregationServiceFactoryDesc, builtinBean, VariableNames, agentInstanceViewFactoryContext));
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return false;
}
var evalEvent = new ObjectArrayEventBean(new object[1], _forge.type);
eventsLambda[_forge.StreamNumLambda] = evalEvent;
var props = evalEvent.Properties;
foreach (var next in enumcoll) {
props[0] = next;
var pass = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (pass != null && ((Boolean) pass)) {
return true;
}
}
return false;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.Count <= 1) {
return enumcoll;
}
IDictionary<IComparable, object> distinct = new LinkedHashMap<IComparable, object>();
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
var values = enumcoll;
foreach (var next in values) {
props[0] = next;
var comparable = (IComparable) _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (!distinct.ContainsKey(comparable)) {
distinct.Put(comparable, next);
}
}
return distinct.Values;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
var sum = 0d;
var count = 0;
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
var values = (ICollection<object>) enumcoll;
foreach (var next in values) {
props[0] = next;
var num = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (num == null) {
continue;
}
count++;
sum += num.AsDouble();
}
if (count == 0) {
return null;
}
return sum / count;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return enumcoll;
}
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
Deque<object> result = new ArrayDeque<object>(enumcoll.Count);
var values = (ICollection<object>) enumcoll;
foreach (var next in values) {
props[0] = next;
var item = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (item != null) {
result.Add(item);
}
}
return result;
}
public Object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection <object> target,
bool isNewData,
ExprEvaluatorContext context)
{
if (target == null || target.Count < 2)
{
return(target);
}
var evaluateParams = new EvaluateParams(eventsLambda, isNewData, context);
var set = new LinkedHashMap <IComparable, Object>();
var resultEvent = new ObjectArrayEventBean(new Object[1], _resultEventType);
var values = target;
foreach (Object next in values)
{
resultEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = resultEvent;
var comparable = (IComparable)InnerExpression.Evaluate(evaluateParams);
if (!set.ContainsKey(comparable))
{
set.Put(comparable, next);
}
}
return(set.Values);
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return new EmptyDictionary<object, object>();
}
IDictionary<object, object> map = new Dictionary<object, object>();
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
var values = enumcoll;
foreach (var next in values) {
props[0] = next;
var key = _innerExpression.Evaluate(eventsLambda, isNewData, context);
var value = _secondExpression.Evaluate(eventsLambda, isNewData, context);
map.Put(key, value);
}
return map;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return enumcoll;
}
var result = new ArrayDeque<object>();
var evalEvent = new ObjectArrayEventBean(new object[1], _forge.evalEventType);
eventsLambda[_forge.streamNumLambda] = evalEvent;
var evalProps = evalEvent.Properties;
var indexEvent = new ObjectArrayEventBean(new object[1], _forge.indexEventType);
eventsLambda[_forge.streamNumLambda + 1] = indexEvent;
var indexProps = indexEvent.Properties;
var count = -1;
foreach (var next in enumcoll) {
count++;
evalProps[0] = next;
indexProps[0] = count;
var pass = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (pass == null || false.Equals(pass)) {
continue;
}
result.Add(next);
}
return result;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
var count = 0;
var evalEvent = new ObjectArrayEventBean(new object[1], _forge.type);
eventsLambda[_forge.StreamNumLambda] = evalEvent;
var props = evalEvent.Properties;
foreach (var next in enumcoll) {
props[0] = next;
var pass = _innerExpression.Evaluate(eventsLambda, isNewData, context);
if (pass == null || false.Equals(pass)) {
continue;
}
count++;
}
return count;
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
if (enumcoll.IsEmpty()) {
return null;
}
IDictionary<object, int> items = new LinkedHashMap<object, int>();
var values = (ICollection<object>) enumcoll;
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.resultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
foreach (var next in values) {
props[0] = next;
var item = _innerExpression.Evaluate(eventsLambda, isNewData, context);
int? existing = items.Get(item);
if (existing == null) {
existing = 1;
}
else {
existing++;
}
items.Put(item, existing.Value);
}
return EnumMostLeastFrequentEventForgeEval.GetEnumMostLeastFrequentResult(items, _forge.isMostFrequent);
}
public Object EvaluateEnumMethod(EventBean[] eventsLambda,
ICollection <object> target,
bool isNewData,
ExprEvaluatorContext context)
{
double sum = 0d;
int count = 0;
var resultEvent = new ObjectArrayEventBean(new Object[1], _resultEventType);
ICollection <object> values = target;
foreach (object next in values)
{
resultEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = resultEvent;
object num = InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (num == null)
{
continue;
}
count++;
sum += num.AsDouble();
}
if (count == 0)
{
return(null);
}
return(sum / count);
}
public override Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
if (target.IsEmpty())
{
return(target);
}
var result = new LinkedList <Object>();
var indexEvent = new ObjectArrayEventBean(new Object[1], IndexEventType);
int count = -1;
foreach (EventBean next in target)
{
count++;
indexEvent.Properties[0] = count;
eventsLambda[StreamNumLambda] = next;
eventsLambda[StreamNumLambda + 1] = indexEvent;
var pass = (bool?)InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (!pass.HasValue || !pass.Value)
{
continue;
}
result.AddLast(next);
}
return(result);
}
public object EvaluateEnumMethod(
EventBean[] eventsLambda,
ICollection<object> enumcoll,
bool isNewData,
ExprEvaluatorContext context)
{
var value = _initialization.Evaluate(eventsLambda, isNewData, context);
if (enumcoll.IsEmpty()) {
return value;
}
var beans = (ICollection<EventBean>) enumcoll;
var resultEvent = new ObjectArrayEventBean(new object[1], _forge.ResultEventType);
eventsLambda[_forge.StreamNumLambda] = resultEvent;
var props = resultEvent.Properties;
foreach (var next in beans) {
props[0] = value;
eventsLambda[_forge.StreamNumLambda + 1] = next;
value = _innerExpression.Evaluate(eventsLambda, isNewData, context);
}
return value;
}
public override Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
if (target.IsEmpty())
{
return(target);
}
var result = new LinkedList <Object>();
var evalEvent = new ObjectArrayEventBean(new Object[1], Type);
foreach (Object next in target)
{
evalEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = evalEvent;
var pass = (bool?)InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (!pass.GetValueOrDefault(false))
{
continue;
}
result.AddLast(next);
}
return(result);
}
public Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
var items = new LinkedHashMap <Object, int?>();
var values = target;
var resultEvent = new ObjectArrayEventBean(new Object[1], _resultEventType);
foreach (Object next in values)
{
resultEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = resultEvent;
var item = InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
int?existing;
if (!items.TryGetValue(item, out existing))
{
existing = 1;
}
else
{
existing++;
}
items.Put(item, existing);
}
return(EnumEvalMostLeastFrequentEvent.GetResult(items, _isMostFrequent));
}
public void UpdateTable(
ICollection <EventBean> eventsUnsafeIter,
TableStateInstance instance,
EventBean[] eventsPerStream,
ExprEvaluatorContext exprEvaluatorContext)
{
// update (no-copy unless original values required)
foreach (EventBean @event in eventsUnsafeIter)
{
eventsPerStream[0] = @event;
var updatedEvent = (ObjectArrayBackedEventBean)@event;
// if "initial.property" is part of the assignment expressions, provide initial value event
if (_updateHelper.IsRequiresStream2InitialValueEvent)
{
var prev = new object[updatedEvent.Properties.Length];
Array.Copy(updatedEvent.Properties, 0, prev, 0, prev.Length);
eventsPerStream[2] = new ObjectArrayEventBean(prev, updatedEvent.EventType);
}
// apply in-place updates
_updateHelper.UpdateNoCopy(updatedEvent, eventsPerStream, exprEvaluatorContext);
instance.HandleRowUpdated(updatedEvent);
}
}
public Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
if (target.IsEmpty())
{
return(target);
}
var resultEvent = new ObjectArrayEventBean(new Object[1], _resultEventType);
var values = (ICollection <Object>)target;
var queue = new LinkedList <object>();
foreach (Object next in values)
{
resultEvent.Properties[0] = next;
eventsLambda[StreamNumLambda] = resultEvent;
var item = InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (item != null)
{
queue.AddLast(item);
}
}
return(queue);
}
public ExpressionBatchView(
ExpressionBatchViewFactory factory,
ViewUpdatedCollection viewUpdatedCollection,
ObjectArrayEventBean builtinEventProps,
AgentInstanceViewFactoryChainContext agentInstanceContext)
: base(factory, viewUpdatedCollection, builtinEventProps, agentInstanceContext)
{
}
public override Object EvaluateEnumMethod(EventBean[] eventsLambda, ICollection <object> target, bool isNewData, ExprEvaluatorContext context)
{
if (target.IsEmpty())
{
return(target);
}
var evalEvent = new ObjectArrayEventBean(new Object[1], EvalEventType);
var indexEvent = new ObjectArrayEventBean(new Object[1], IndexEventType);
if (target.Count == 1)
{
Object item = target.First();
evalEvent.Properties[0] = item;
eventsLambda[StreamNumLambda] = evalEvent;
indexEvent.Properties[0] = 0;
eventsLambda[StreamNumLambda + 1] = indexEvent;
var pass = (bool?)InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (!pass.GetValueOrDefault(false))
{
return(Collections.GetEmptyList <object>());
}
return(Collections.SingletonList(item));
}
var size = target.Count;
var all = new Object[size];
var count = 0;
foreach (Object item in target)
{
all[count++] = item;
}
var result = new LinkedList <Object>();
int index = 0;
for (int i = all.Length - 1; i >= 0; i--)
{
evalEvent.Properties[0] = all[i];
eventsLambda[StreamNumLambda] = evalEvent;
indexEvent.Properties[0] = index++;
eventsLambda[StreamNumLambda + 1] = indexEvent;
var pass = (bool?)InnerExpression.Evaluate(new EvaluateParams(eventsLambda, isNewData, context));
if (!pass.GetValueOrDefault(false))
{
break;
}
result.AddFirst(all[i]);
}
return(result);
}
protected ExpressionViewBase(
ViewUpdatedCollection viewUpdatedCollection,
ExprEvaluator expiryExpression,
AggregationServiceFactoryDesc aggregationServiceFactoryDesc,
ObjectArrayEventBean builtinEventProps,
ISet <String> variableNames,
AgentInstanceViewFactoryChainContext agentInstanceContext)
{
ViewUpdatedCollection = viewUpdatedCollection;
ExpiryExpression = expiryExpression;
BuiltinEventProps = builtinEventProps;
EventsPerStream = new EventBean[] { null, builtinEventProps };
VariableNames = variableNames;
AgentInstanceContext = agentInstanceContext;
if (variableNames != null && !variableNames.IsEmpty())
{
foreach (String variable in variableNames)
{
var variableName = variable;
var agentInstanceId = agentInstanceContext.AgentInstanceId;
var variableService = agentInstanceContext.StatementContext.VariableService;
agentInstanceContext.StatementContext.VariableService.RegisterCallback(variable, agentInstanceId, Update);
agentInstanceContext.AddTerminationCallback(
new ProxyStopCallback(() => variableService.UnregisterCallback(variableName, agentInstanceId, Update)));
}
ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
{
ProcScheduledTrigger = extensionServicesContext => Instrument.With(
i => i.QViewScheduledEval(this, ViewName),
i => i.AViewScheduledEval(),
ScheduleCallback)
};
ScheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
ScheduleHandle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, callback);
agentInstanceContext.AddTerminationCallback(this);
}
else
{
ScheduleSlot = -1;
ScheduleHandle = null;
}
if (aggregationServiceFactoryDesc != null)
{
AggregationService = aggregationServiceFactoryDesc.AggregationServiceFactory.MakeService(
agentInstanceContext.AgentInstanceContext,
agentInstanceContext.AgentInstanceContext.StatementContext.EngineImportService, false, null);
AggregateNodes = aggregationServiceFactoryDesc.Expressions;
}
else
{
AggregationService = null;
AggregateNodes = Collections.GetEmptyList <AggregationServiceAggExpressionDesc>();
}
}
public override View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
var builtinBean = new ObjectArrayEventBean(
ExpressionViewOAFieldEnumExtensions.GetPrototypeOA(),
BuiltinMapType);
var randomAccess =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRandomAccess(agentInstanceViewFactoryContext);
return new ExpressionWindowView(this, randomAccess, builtinBean, agentInstanceViewFactoryContext);
}
public OutputConditionPolledExpression(
OutputConditionPolledExpressionFactory factory,
OutputConditionPolledExpressionState state,
AgentInstanceContext agentInstanceContext,
ObjectArrayEventBean builtinProperties)
{
_factory = factory;
_state = state;
_builtinProperties = builtinProperties;
_agentInstanceContext = agentInstanceContext;
}
/// <summary>
/// Constructor creates a moving window extending the specified number of elements into the past.
/// </summary>
/// <param name="dataWindowViewFactory">for copying this view in a group-by</param>
/// <param name="viewUpdatedCollection">is a collection that the view must update when receiving events</param>
/// <param name="expiryExpression">The expiry expression.</param>
/// <param name="AggregationServiceFactoryDesc">The aggregation service factory desc.</param>
/// <param name="builtinEventProps">The builtin event props.</param>
/// <param name="variableNames">variable names</param>
/// <param name="AgentInstanceContext">The agent instance context.</param>
public ExpressionWindowView(ExpressionWindowViewFactory dataWindowViewFactory,
ViewUpdatedCollection viewUpdatedCollection,
ExprEvaluator expiryExpression,
AggregationServiceFactoryDesc AggregationServiceFactoryDesc,
ObjectArrayEventBean builtinEventProps,
ISet <String> variableNames,
AgentInstanceViewFactoryChainContext AgentInstanceContext)
: base(viewUpdatedCollection, expiryExpression, AggregationServiceFactoryDesc, builtinEventProps, variableNames, AgentInstanceContext)
{
_dataWindowViewFactory = dataWindowViewFactory;
}
public OutputConditionPolled MakeFromState(AgentInstanceContext agentInstanceContext, OutputConditionPolledState state)
{
ObjectArrayEventBean builtinProperties = null;
if (_oatypeBuiltinProperties != null)
{
builtinProperties = new ObjectArrayEventBean(OutputConditionExpressionTypeUtil.OAPrototype, _oatypeBuiltinProperties);
}
var expressionState = (OutputConditionPolledExpressionState)state;
return(new OutputConditionPolledExpression(this, expressionState, agentInstanceContext, builtinProperties));
}
public OutputConditionPolled MakeNew(AgentInstanceContext agentInstanceContext)
{
ObjectArrayEventBean builtinProperties = null;
long?lastOutputTimestamp = null;
if (_oatypeBuiltinProperties != null)
{
builtinProperties = new ObjectArrayEventBean(OutputConditionExpressionTypeUtil.OAPrototype, _oatypeBuiltinProperties);
lastOutputTimestamp = agentInstanceContext.StatementContext.SchedulingService.Time;
}
var state = new OutputConditionPolledExpressionState(0, 0, 0, 0, lastOutputTimestamp);
return(new OutputConditionPolledExpression(this, state, agentInstanceContext, builtinProperties));
}
public void UpdateTable(
ICollection <EventBean> eventsUnsafeIter,
TableStateInstance instance,
EventBean[] eventsPerStream,
ExprEvaluatorContext exprEvaluatorContext)
{
// copy references to array - as it is allowed to pass an index-originating collection
// and those same indexes are being changed now
var events = new EventBean[eventsUnsafeIter.Count];
int count = 0;
foreach (EventBean @event in eventsUnsafeIter)
{
events[count++] = @event;
}
// remove from affected indexes
foreach (string affectedIndexName in _affectedIndexNames)
{
EventTable index = instance.GetIndex(affectedIndexName);
index.Remove(events, instance.AgentInstanceContext);
}
// update (no-copy unless original values required)
foreach (EventBean @event in events)
{
eventsPerStream[0] = @event;
var updatedEvent = (ObjectArrayBackedEventBean)@event;
// if "initial.property" is part of the assignment expressions, provide initial value event
if (_updateHelper.IsRequiresStream2InitialValueEvent)
{
var prev = new object[updatedEvent.Properties.Length];
Array.Copy(updatedEvent.Properties, 0, prev, 0, prev.Length);
eventsPerStream[2] = new ObjectArrayEventBean(prev, updatedEvent.EventType);
}
// apply in-place updates
_updateHelper.UpdateNoCopy(updatedEvent, eventsPerStream, exprEvaluatorContext);
instance.HandleRowUpdated(updatedEvent);
}
// add to affected indexes
foreach (string affectedIndexName in _affectedIndexNames)
{
EventTable index = instance.GetIndex(affectedIndexName);
index.Add(events, instance.AgentInstanceContext);
}
}
