Java ValueAddEventProcessor类代码示例

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowProcessor addProcessor(String name, String contextName, EventType eventType, StatementResultService statementResultService,
                                         ValueAddEventProcessor revisionProcessor, String eplExpression, String statementName, boolean isPrioritized,
                                         boolean isEnableSubqueryIndexShare, boolean isBatchingDataWindow,
                                         boolean isVirtualDataWindow,
                                         Set<String> optionalUniqueKeyProps, String eventTypeAsName,
                                         StatementContext statementContextCreateWindow,
                                         NamedWindowDispatchService namedWindowDispatchService) throws ViewProcessingException {
    if (processors.containsKey(name)) {
        throw new ViewProcessingException("A named window by name '" + name + "' has already been created");
    }

    NamedWindowProcessor processor = namedWindowDispatchService.createProcessor(name, this, namedWindowDispatchService, contextName, eventType, statementResultService, revisionProcessor, eplExpression, statementName, isPrioritized, isEnableSubqueryIndexShare, enableQueryPlanLog, metricReportingService, isBatchingDataWindow, isVirtualDataWindow, optionalUniqueKeyProps, eventTypeAsName, statementContextCreateWindow);
    processors.put(name, processor);

    if (!observers.isEmpty()) {
        NamedWindowLifecycleEvent theEvent = new NamedWindowLifecycleEvent(name, processor, NamedWindowLifecycleEvent.LifecycleEventType.CREATE);
        for (NamedWindowLifecycleObserver observer : observers) {
            observer.observe(theEvent);
        }
    }

    return processor;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
/**
 * Ctor.
 * @param namedWindowService service for dispatching results
 * @param eventType the type of event held by the named window
 * @param statementResultService for coordinating on whether insert and remove stream events should be posted
 * @param revisionProcessor for revision processing
 * @param eplExpression epl expression
 * @param statementName statement name
 * @param isPrioritized if the engine is running with prioritized execution
 */
public NamedWindowProcessor(String namedWindowName, NamedWindowService namedWindowService, String contextName, boolean singleInstanceContext, EventType eventType, StatementResultService statementResultService, ValueAddEventProcessor revisionProcessor, String eplExpression, String statementName, boolean isPrioritized, boolean isEnableSubqueryIndexShare, boolean enableQueryPlanLog, MetricReportingService metricReportingService, boolean isBatchingDataWindow, boolean isVirtualDataWindow, StatementMetricHandle statementMetricHandle, Set<String> optionalUniqueKeyProps)
{
    this.namedWindowName = namedWindowName;
    this.contextName = contextName;
    this.singleInstanceContext = singleInstanceContext;
    this.eventType = eventType;
    this.eplExpression = eplExpression;
    this.statementName = statementName;
    this.isEnableSubqueryIndexShare = isEnableSubqueryIndexShare;
    this.isVirtualDataWindow = isVirtualDataWindow;
    this.statementMetricHandle = statementMetricHandle;
    this.optionalUniqueKeyProps = optionalUniqueKeyProps;

    rootView = new NamedWindowRootView(revisionProcessor, enableQueryPlanLog, metricReportingService, eventType, isBatchingDataWindow, isEnableSubqueryIndexShare, optionalUniqueKeyProps);
    tailView = new NamedWindowTailView(eventType, namedWindowService, statementResultService, revisionProcessor, isPrioritized, isBatchingDataWindow);
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowProcessor addProcessor(String name, String contextName, boolean singleInstanceContext, EventType eventType, StatementResultService statementResultService,
                                         ValueAddEventProcessor revisionProcessor, String eplExpression, String statementName, boolean isPrioritized,
                                         boolean isEnableSubqueryIndexShare, boolean isBatchingDataWindow,
                                         boolean isVirtualDataWindow, StatementMetricHandle statementMetricHandle,
                                         Set<String> optionalUniqueKeyProps) throws ViewProcessingException
{
    if (processors.containsKey(name))
    {
        throw new ViewProcessingException("A named window by name '" + name + "' has already been created");
    }

    NamedWindowProcessor processor = new NamedWindowProcessor(name, this, contextName, singleInstanceContext, eventType, statementResultService, revisionProcessor, eplExpression, statementName, isPrioritized, isEnableSubqueryIndexShare, enableQueryPlanLog, metricReportingService, isBatchingDataWindow, isVirtualDataWindow, statementMetricHandle, optionalUniqueKeyProps);
    processors.put(name, processor);

    if (!observers.isEmpty())
    {
        NamedWindowLifecycleEvent theEvent = new NamedWindowLifecycleEvent(name, processor, NamedWindowLifecycleEvent.LifecycleEventType.CREATE);
        for (NamedWindowLifecycleObserver observer : observers)
        {
            observer.observe(theEvent);
        }
    }

    return processor;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowRootView(ValueAddEventProcessor revisionProcessor, boolean queryPlanLogging, MetricReportingService metricReportingService, EventType eventType, boolean childBatching, boolean isEnableIndexShare, Set<String> optionalUniqueKeyProps) {
    this.revisionProcessor = revisionProcessor;
    this.queryPlanLogging = queryPlanLogging;
    this.eventType = eventType;
    this.isChildBatching = childBatching;
    this.isEnableIndexShare = isEnableIndexShare;
    this.optionalUniqueKeyProps = optionalUniqueKeyProps;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowProcessor(String namedWindowName, NamedWindowMgmtService namedWindowMgmtService, NamedWindowDispatchService namedWindowDispatchService, String contextName, EventType eventType, StatementResultService statementResultService, ValueAddEventProcessor revisionProcessor, String eplExpression, String statementName, boolean isPrioritized, boolean isEnableSubqueryIndexShare, boolean enableQueryPlanLog, MetricReportingService metricReportingService, boolean isBatchingDataWindow, boolean isVirtualDataWindow, Set<String> optionalUniqueKeyProps, String eventTypeAsName, StatementContext statementContextCreateWindow) {
    this.namedWindowName = namedWindowName;
    this.contextName = contextName;
    this.eventType = eventType;
    this.eplExpression = eplExpression;
    this.statementName = statementName;
    this.isEnableSubqueryIndexShare = isEnableSubqueryIndexShare;
    this.isVirtualDataWindow = isVirtualDataWindow;
    this.optionalUniqueKeyProps = optionalUniqueKeyProps;
    this.eventTypeAsName = eventTypeAsName;
    this.statementContextCreateWindow = statementContextCreateWindow;

    rootView = new NamedWindowRootView(revisionProcessor, enableQueryPlanLog, metricReportingService, eventType, isBatchingDataWindow, isEnableSubqueryIndexShare, optionalUniqueKeyProps);
    tailView = namedWindowDispatchService.createTailView(eventType, namedWindowMgmtService, namedWindowDispatchService, statementResultService, revisionProcessor, isPrioritized, isBatchingDataWindow, contextName, statementContextCreateWindow.getTimeSourceService(), statementContextCreateWindow.getConfigSnapshot().getEngineDefaults().getThreading());
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowProcessor addProcessor(String name,
String contextName,
EventType eventType,
StatementResultService statementResultService,
ValueAddEventProcessor revisionProcessor,
String eplExpression,
String statementName,
boolean isPrioritized,
boolean isEnableSubqueryIndexShare,
boolean isBatchingDataWindow,
boolean isVirtualDataWindow,
Set<String> optionalUniqueKeyProps,
String eventTypeAsName,
StatementContext statementContextCreateWindow,
NamedWindowDispatchService namedWindowDispatchService) throws ViewProcessingException;
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public NamedWindowTailView(EventType eventType, NamedWindowMgmtService namedWindowMgmtService, NamedWindowDispatchService namedWindowDispatchService, StatementResultService statementResultService, ValueAddEventProcessor revisionProcessor, boolean prioritized, boolean parentBatchWindow, TimeSourceService timeSourceService, ConfigurationEngineDefaults.Threading threadingConfig) {
    this.eventType = eventType;
    this.namedWindowMgmtService = namedWindowMgmtService;
    this.namedWindowDispatchService = namedWindowDispatchService;
    this.statementResultService = statementResultService;
    this.revisionProcessor = revisionProcessor;
    this.isPrioritized = prioritized;
    this.isParentBatchWindow = parentBatchWindow;
    this.consumersNonContext = NamedWindowUtil.createConsumerMap(isPrioritized);
    this.threadingConfig = threadingConfig;
    this.timeSourceService = timeSourceService;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
protected CodegenExpression processFirstColCodegen(Class evaluationType, CodegenExpression expression, CodegenMember memberResultEventType, CodegenMember memberEventAdapterService, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) {
    CodegenMember processor = codegenClassScope.makeAddMember(ValueAddEventProcessor.class, vaeProcessor);
    CodegenMethodNode method = codegenMethodScope.makeChild(EventBean.class, this.getClass(), codegenClassScope).addParam(evaluationType, "result").getBlock()
            .declareVar(EventBean.class, "wrappedEvent", exprDotMethod(member(memberEventAdapterService.getMemberId()), "adapterForBean", ref("result")))
            .declareVar(EventBean.class, "variant", exprDotMethod(member(processor.getMemberId()), "getValueAddEventBean", ref("wrappedEvent")))
            .methodReturn(exprDotMethod(member(memberEventAdapterService.getMemberId()), "adapterForTypedWrapper", ref("variant"), staticMethod(Collections.class, "emptyMap"), member(memberResultEventType.getMemberId())));
    return localMethodBuild(method).pass(expression).call();
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
protected CodegenExpression processFirstColCodegen(Class evaluationType, CodegenExpression expression, CodegenMember memberResultEventType, CodegenMember memberEventAdapterService, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) {
    CodegenMember memberProcessor = codegenClassScope.makeAddMember(ValueAddEventProcessor.class, vaeProcessor);
    CodegenMember memberType = codegenClassScope.makeAddMember(EventType.class, vaeInnerEventType);
    CodegenMember memberFunc = codegenClassScope.makeAddMember(TriFunction.class, func);
    CodegenExpression wrappedEvent = exprDotMethod(CodegenExpressionBuilder.member(memberFunc.getMemberId()), "apply", CodegenExpressionBuilder.member(memberEventAdapterService.getMemberId()), expression, CodegenExpressionBuilder.member(memberResultEventType.getMemberId()));
    CodegenExpression adapter = exprDotMethod(CodegenExpressionBuilder.member(memberEventAdapterService.getMemberId()), "adapterForTypedWrapper", wrappedEvent, staticMethod(Collections.class, "emptyMap"), CodegenExpressionBuilder.member(memberType.getMemberId()));
    return exprDotMethod(CodegenExpressionBuilder.member(memberProcessor.getMemberId()), "getValueAddEventBean", adapter);
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
/**
 * NOTE: Code-generation-invoked method, method name and parameter order matters
 * @param eventsPerStream events
 * @param numEvaluators num evals
 * @param props props
 * @param vaeProcessor processor
 * @return bean
 */
public static EventBean selectExprInsertWildcardSSWrapRevision(EventBean[] eventsPerStream, int numEvaluators, Map<String, Object> props, ValueAddEventProcessor vaeProcessor) {
    DecoratingEventBean wrapper = (DecoratingEventBean) eventsPerStream[0];
    if (wrapper != null) {
        Map<String, Object> map = wrapper.getDecoratingProperties();
        if ((numEvaluators == 0) && (!map.isEmpty())) {
            // no action
        } else {
            props.putAll(map);
        }
    }

    EventBean theEvent = eventsPerStream[0];
    return vaeProcessor.getValueAddEventBean(theEvent);
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public CodegenMethodNode processCodegen(CodegenMember memberResultEventType, CodegenMember memberEventAdapterService, CodegenMethodScope codegenMethodScope, SelectExprProcessorCodegenSymbol selectSymbol, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) {
    CodegenMethodNode methodNode = codegenMethodScope.makeChild(EventBean.class, this.getClass(), codegenClassScope);
    CodegenExpressionRef refEPS = exprSymbol.getAddEPS(methodNode);
    CodegenMember vae = codegenClassScope.makeAddMember(ValueAddEventProcessor.class, vaeProcessor);
    methodNode.getBlock().methodReturn(exprDotMethod(member(vae.getMemberId()), "getValueAddEventBean", arrayAtIndex(refEPS, constant(0))));
    return methodNode;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public CodegenMethodNode processCodegen(CodegenMember memberResultEventType, CodegenMember memberEventAdapterService, CodegenMethodScope codegenMethodScope, SelectExprProcessorCodegenSymbol selectSymbol, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) {
    CodegenMember processor = codegenClassScope.makeAddMember(ValueAddEventProcessor.class, vaeProcessor);
    CodegenMethodNode methodNode = codegenMethodScope.makeChild(EventBean.class, this.getClass(), codegenClassScope);
    CodegenMethodNode jw = joinWildcardProcessorForge.processCodegen(memberResultEventType, memberEventAdapterService, methodNode, selectSymbol, exprSymbol, codegenClassScope);
    methodNode.getBlock().methodReturn(exprDotMethod(CodegenExpressionBuilder.member(processor.getMemberId()), "getValueAddEventBean", localMethod(jw)));
    return methodNode;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
protected CodegenExpression processSpecificCodegen(CodegenMember memberResultEventType, CodegenMember memberEventAdapterService, CodegenExpression props, CodegenMethodNode methodNode, SelectExprProcessorCodegenSymbol selectEnv, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) {
    CodegenMember processor = codegenClassScope.makeAddMember(ValueAddEventProcessor.class, vaeProcessor);
    CodegenMember innerType = codegenClassScope.makeAddMember(EventType.class, wrappingEventType);
    CodegenExpressionRef refEPS = exprSymbol.getAddEPS(methodNode);
    CodegenExpression wrapped = exprDotMethod(member(memberEventAdapterService.getMemberId()), "adapterForTypedWrapper", arrayAtIndex(refEPS, constant(0)), ref("props"), member(innerType.getMemberId()));
    return exprDotMethod(member(processor.getMemberId()), "getValueAddEventBean", wrapped);
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
public boolean isVariantStreamExists(String name) {
    ValueAddEventProcessor processor = valueAddEventService.getValueAddProcessor(name);
    if (processor == null) {
        return false;
    }
    return processor.getValueAddEventType() instanceof VariantEventType;
}
 

import com.espertech.esper.event.vaevent.ValueAddEventProcessor; //导入依赖的package包/类
/**
 * Create a new named window.
 * @param name window name
 * @param eventType the event type of the window
 * @param statementResultService for coordinating on whether insert and remove stream events should be posted
 * @param revisionProcessor handles update events
 * @param eplExpression is the expression
 * @param statementName the name of the statement
 * @param isPrioritized if the engine is running with prioritized execution
 * @return processor for the named window
 * @throws ViewProcessingException if the named window already exists
 */
public NamedWindowProcessor addProcessor(String name,
                                         String contextName,
                                         boolean singleInstanceContext,
                                         EventType eventType,
                                         StatementResultService statementResultService,
                                         ValueAddEventProcessor revisionProcessor,
                                         String eplExpression,
                                         String statementName,
                                         boolean isPrioritized,
                                         boolean isEnableSubqueryIndexShare,
                                         boolean isBatchingDataWindow,
                                         boolean isVirtualDataWindow,
                                         StatementMetricHandle statementMetricHandle,
                                         Set<String> optionalUniqueKeyProps) throws ViewProcessingException;