Java EventBeanUtility.allocatePerStreamShift方法代码示例

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Collection<EventBean> evaluateGetCollEvents(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);

    ArrayDeque<EventBean> filtered = null;
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) parent.filterExpr.evaluate(events, true, context);
        if ((pass != null) && pass) {
            if (filtered == null) {
                filtered = new ArrayDeque<EventBean>();
            }
            filtered.add(subselectEvent);
        }
    }
    return filtered;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {

        AggregationService aggregationService = parent.getSubselectAggregationService().getContextPartitionAggregationService(exprEvaluatorContext.getAgentInstanceId());
        Collection<Object> groupKeys = aggregationService.getGroupKeys(exprEvaluatorContext);
        if (groupKeys.isEmpty()) {
            return null;
        }

        EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
        boolean haveResult = false;
        Object result = null;
        for (Object groupKey : groupKeys) {
            aggregationService.setCurrentAccess(groupKey, exprEvaluatorContext.getAgentInstanceId(), null);
            Boolean pass = (Boolean) havingClause.evaluate(events, newData, exprEvaluatorContext);
            if (pass != null && pass) {
                if (haveResult) {
                    return null;
                }

                result = super.evaluate(eventsPerStream, newData, matchingEvents, exprEvaluatorContext, parent);
                haveResult = true;
            }
        }

        return haveResult ? result : null;
    }
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Collection<EventBean> evaluateGetCollEvents(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    AggregationService aggregationService = parent.getSubselectAggregationService().getContextPartitionAggregationService(context.getAgentInstanceId());
    Collection<Object> groupKeys = aggregationService.getGroupKeys(context);
    if (groupKeys.isEmpty()) {
        return null;
    }
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    Collection<EventBean> result = new ArrayDeque<EventBean>(groupKeys.size());
    for (Object groupKey : groupKeys) {
        aggregationService.setCurrentAccess(groupKey, context.getAgentInstanceId(), null);

        Boolean pass = (Boolean) havingClause.evaluate(events, newData, context);
        if (pass != null && pass) {
            Map<String, Object> row = parent.evaluateRow(events, true, context);
            EventBean event = parent.subselectMultirowType.getEventAdapterService().adapterForTypedMap(row, parent.subselectMultirowType.getEventType());
            result.add(event);
        }
    }
    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] eventsZeroBased = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(eventsZeroBased, newData, matchingEvents, exprEvaluatorContext, parent);
    if (subSelectResult == null) {
        return null;
    }

    eventsZeroBased[0] = subSelectResult;
    Object result;
    if (parent.selectClauseEvaluator.length == 1) {
        result = parent.selectClauseEvaluator[0].evaluate(eventsZeroBased, true, exprEvaluatorContext);
    } else {
        // we are returning a Map here, not object-array, preferring the self-describing structure
        result = parent.evaluateRow(eventsZeroBased, true, exprEvaluatorContext);
    }

    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, AggregationService aggregationServiceAnyPartition) {
    if (matchingEvents == null || matchingEvents.size() == 0) {
        return false;
    }
    AggregationService aggregationService = aggregationServiceAnyPartition.getContextPartitionAggregationService(exprEvaluatorContext.getAgentInstanceId());
    Collection<Object> groupKeys = aggregationService.getGroupKeys(exprEvaluatorContext);
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (Object groupKey : groupKeys) {
        aggregationService.setCurrentAccess(groupKey, exprEvaluatorContext.getAgentInstanceId(), null);

        Boolean pass = (Boolean) havingEval.evaluate(events, true, exprEvaluatorContext);
        if ((pass == null) || (!pass)) {
            continue;
        }
        return true;
    }
    return false;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] eventsZeroBased = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    Boolean pass = (Boolean) parent.havingExpr.evaluate(eventsZeroBased, newData, exprEvaluatorContext);
    if ((pass == null) || (!pass)) {
        return null;
    }

    Object result;
    if (parent.selectClauseEvaluator.length == 1) {
        result = parent.selectClauseEvaluator[0].evaluate(eventsZeroBased, true, exprEvaluatorContext);
    } else {
        // we are returning a Map here, not object-array, preferring the self-describing structure
        result = parent.evaluateRow(eventsZeroBased, true, exprEvaluatorContext);
    }

    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext,
                       ExprSubselectRowNode parent) {
    if (matchingEvents.size() > 1) {
        log.warn(parent.getMultirowMessage());
        return null;
    }

    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    events[0] = EventBeanUtility.getNonemptyFirstEvent(matchingEvents);

    Object result;
    if (parent.selectClauseEvaluator.length == 1) {
        result = parent.selectClauseEvaluator[0].evaluate(events, true, exprEvaluatorContext);
    } else {
        // we are returning a Map here, not object-array, preferring the self-describing structure
        result = parent.evaluateRow(events, true, exprEvaluatorContext);
    }
    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] eventsZeroBased = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(eventsZeroBased, newData, matchingEvents, exprEvaluatorContext, parent);
    if (subSelectResult == null) {
        return null;
    }
    return subSelectResult.getUnderlying();
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Collection evaluateGetCollScalar(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    List<Object> result = new ArrayList<Object>();
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        Boolean pass = (Boolean) parent.filterExpr.evaluate(events, true, context);
        if ((pass != null) && pass) {
            result.add(parent.selectClauseEvaluator[0].evaluate(events, isNewData, context));
        }
    }
    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object[] typableEvaluate(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(events, isNewData, matchingEvents, exprEvaluatorContext, parent);
    if (subSelectResult == null) {
        return null;
    }

    events[0] = subSelectResult;
    Object[] results = new Object[parent.selectClauseEvaluator.length];
    for (int i = 0; i < results.length; i++) {
        results[i] = parent.selectClauseEvaluator[i].evaluate(events, isNewData, exprEvaluatorContext);
    }
    return results;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object[][] typableEvaluateMultirow(EventBean[] eventsPerStream, boolean newData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    Object[][] rows = new Object[matchingEvents.size()][];
    int index = -1;
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (EventBean matchingEvent : matchingEvents) {
        events[0] = matchingEvent;

        Boolean pass = (Boolean) parent.filterExpr.evaluate(events, newData, exprEvaluatorContext);
        if ((pass != null) && pass) {
            index++;
            Object[] results = new Object[parent.selectClauseEvaluator.length];
            for (int i = 0; i < results.length; i++) {
                results[i] = parent.selectClauseEvaluator[i].evaluate(events, newData, exprEvaluatorContext);
            }
            rows[index] = results;
        }
    }
    if (index == rows.length - 1) {
        return rows;
    }
    if (index == -1) {
        return CollectionUtil.OBJECTARRAYARRAY_EMPTY;
    }
    int access = index + 1;
    Object[][] rowArray = new Object[access][];
    System.arraycopy(rows, 0, rowArray, 0, rowArray.length);
    return rowArray;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public EventBean evaluateGetEventBean(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    EventBean subSelectResult = ExprSubselectRowNodeUtility.evaluateFilterExpectSingleMatch(events, isNewData, matchingEvents, context, parent);
    if (subSelectResult == null) {
        return null;
    }
    Map<String, Object> row = parent.evaluateRow(events, true, context);
    return parent.subselectMultirowType.getEventAdapterService().adapterForTypedMap(row, parent.subselectMultirowType.getEventType());
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, AggregationService aggregationService) {
    if (matchingEvents == null || matchingEvents.size() == 0) {
        return resultWhenNoMatchingEvents;
    }

    Object leftResult = valueEval.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    return evaluateInternal(leftResult, events, isNewData, matchingEvents, exprEvaluatorContext, aggregationService);
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Collection evaluateGetCollScalar(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext context, ExprSubselectRowNode parent) {
    List<Object> result = new ArrayList<Object>();
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    for (EventBean subselectEvent : matchingEvents) {
        events[0] = subselectEvent;
        result.add(parent.selectClauseEvaluator[0].evaluate(events, isNewData, context));
    }
    return result;
}
 

import com.espertech.esper.event.EventBeanUtility; //导入方法依赖的package包/类
public Object[] typableEvaluate(EventBean[] eventsPerStream, boolean isNewData, Collection<EventBean> matchingEvents, ExprEvaluatorContext exprEvaluatorContext, ExprSubselectRowNode parent) {
    // take the first match only
    EventBean[] events = EventBeanUtility.allocatePerStreamShift(eventsPerStream);
    events[0] = EventBeanUtility.getNonemptyFirstEvent(matchingEvents);
    Object[] results = new Object[parent.selectClauseEvaluator.length];
    for (int i = 0; i < results.length; i++) {
        results[i] = parent.selectClauseEvaluator[i].evaluate(events, isNewData, exprEvaluatorContext);
    }
    return results;
}