private FileBeginEndProcessor getBeginEndProcessor(DataFlowOpInitializeContext context, int outputPort) { EventType portEventType = factory.getOutputPortTypes()[outputPort]; Set<WriteablePropertyDescriptor> writeables = EventTypeUtility.getWriteableProperties(portEventType, false, false); List<WriteablePropertyDescriptor> writeableList = new ArrayList<WriteablePropertyDescriptor>(); EventBeanManufacturer manufacturer; if (propertyNameFile != null) { WriteablePropertyDescriptor writeableFile = EventTypeUtility.findWritable(propertyNameFile, writeables); if (writeableFile == null || writeableFile.getType() != String.class) { throw new EPException("Failed to find writable String-type property '" + propertyNameFile + "', is the property read-only?"); } writeableList.add(writeableFile); } try { manufacturer = EventTypeUtility.getManufacturer(portEventType, writeableList.toArray(new WriteablePropertyDescriptor[writeableList.size()]), context.getAgentInstanceContext().getClasspathImportServiceRuntime(), false, context.getAgentInstanceContext().getEventTypeAvroHandler()).getManufacturer(context.getAgentInstanceContext().getEventBeanTypedEventFactory()); } catch (EventBeanManufactureException e) { throw new EPException("Event type '" + portEventType.getName() + "' cannot be written to: " + e.getMessage(), e); } return new FileBeginEndProcessorGeneralPurpose(manufacturer); }
public static CodegenExpression resolveTypeArrayCodegen(EventType[] eventTypes, CodegenExpression initServicesRef) { CodegenExpression[] expressions = new CodegenExpression[eventTypes.length]; for (int i = 0; i < eventTypes.length; i++) { expressions[i] = resolveTypeCodegen(eventTypes[i], initServicesRef); } return newArrayWithInit(EventType.class, expressions); }
private static Class resolveClassForTypeName(String type, ClasspathImportService classpathImportService) { boolean isArray = false; if (type != null && EventTypeUtility.isPropertyArray(type)) { isArray = true; type = EventTypeUtility.getPropertyRemoveArray(type); } if (type == null) { throw new ConfigurationException("A null value has been provided for the type"); } Class clazz = JavaClassHelper.getClassForSimpleName(type, classpathImportService.getClassForNameProvider()); if (clazz == null) { return null; } if (isArray) { clazz = Array.newInstance(clazz, 0).getClass(); } return clazz; } }
private static WriteablePropertyDescriptor[] setupProperties(String[] propertyNamesOffered, EventType outputEventType) throws ExprValidationException { Set<WriteablePropertyDescriptor> writeables = EventTypeUtility.getWriteableProperties(outputEventType, false, false); List<WriteablePropertyDescriptor> writablesList = new ArrayList<WriteablePropertyDescriptor>(); for (int i = 0; i < propertyNamesOffered.length; i++) { String propertyName = propertyNamesOffered[i]; WriteablePropertyDescriptor writable = EventTypeUtility.findWritable(propertyName, writeables); if (writable == null) { throw new ExprValidationException("Failed to find writable property '" + propertyName + "' for event type '" + outputEventType.getName() + "'"); } writablesList.add(writable); } return writablesList.toArray(new WriteablePropertyDescriptor[writablesList.size()]); } }
Set<WriteablePropertyDescriptor> writablesSet = EventTypeUtility.getWriteableProperties(eventTypeSPI, false, false); List<WriteablePropertyDescriptor> writablePropertiesList = new ArrayList<WriteablePropertyDescriptor>(); List<SimpleTypeParser> parserList = new ArrayList<SimpleTypeParser>(); eventBeanManufacturer = EventTypeUtility.getManufacturer(eventType, writableProperties, runtime.getServicesContext().getClasspathImportServiceRuntime(), false, runtime.getServicesContext().getEventTypeAvroHandler()).getManufacturer(runtime.getServicesContext().getEventBeanTypedEventFactory()); } catch (EventBeanManufactureException e) { log.info("Unable to create manufacturer for event type: " + e.getMessage(), e);
public void provideCodegen(CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenExpressionRef spec = ref("spec"); method.getBlock() .declareVar(OutputProcessViewConditionSpec.class, spec.getRef(), newInstance(OutputProcessViewConditionSpec.class)) .exprDotMethod(spec, "setConditionType", enumValue(ResultSetProcessorOutputConditionType.class, conditionType.name())) .exprDotMethod(spec, "setOutputConditionFactory", outputConditionFactoryForge.make(method, symbols, classScope)) .exprDotMethod(spec, "setStreamCount", constant(streamCount)) .exprDotMethod(spec, "setTerminable", constant(terminable)) .exprDotMethod(spec, "setSelectClauseStreamSelector", enumValue(SelectClauseStreamSelectorEnum.class, selectClauseStreamSelector.name())) .exprDotMethod(spec, "setPostProcessFactory", outputStrategyPostProcessForge == null ? constantNull() : outputStrategyPostProcessForge.make(method, symbols, classScope)) .exprDotMethod(spec, "setHasAfter", constant(hasAfter)) .exprDotMethod(spec, "setDistinct", constant(isDistinct)) .exprDotMethod(spec, "setResultEventType", EventTypeUtility.resolveTypeCodegen(resultEventType, symbols.getAddInitSvc(method))) .exprDotMethod(spec, "setAfterTimePeriod", afterTimePeriodExpr == null ? constantNull() : afterTimePeriodExpr.getTimePeriodComputeForge().makeEvaluator(method, classScope)) .exprDotMethod(spec, "setAfterConditionNumberOfEvents", constant(afterNumberOfEvents)) .exprDotMethod(spec, "setUnaggregatedUngrouped", constant(unaggregatedUngrouped)) .exprDotMethod(spec, "setEventTypes", EventTypeUtility.resolveTypeArrayCodegen(eventTypes, EPStatementInitServices.REF)) .methodReturn(newInstance(OutputProcessViewConditionFactory.class, spec)); }
EventTypeAvroHandler eventTypeAvroHandler) throws ExprValidationException { Set<WriteablePropertyDescriptor> writableProps = EventTypeUtility.getWriteableProperties(eventType, false, false); boolean isEligible = checkEligible(eventType, writableProps, false); if (!isEligible) {
public SAIFFInitializeBuilder eventtypes(String name, EventType[] types) { return setValue(name, types == null ? constantNull() : EventTypeUtility.resolveTypeArrayCodegen(types, symbols.getAddInitSvc(method))); }
eventManufacturer = EventTypeUtility.getManufacturer(eventType, writableProperties, classpathImportService, false, eventTypeAvroHandler); } catch (EventBeanManufactureException e) { throw new ExprValidationException(e.getMessage(), e);
public CodegenExpression evaluateCodegen(Class requiredType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { CodegenExpressionField eventSvc = codegenClassScope.addOrGetFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); CodegenExpressionField namedWindowType = codegenClassScope.addFieldUnshared(true, EventType.class, EventTypeUtility.resolveTypeCodegen(namedWindowAsType, EPStatementInitServices.REF)); CodegenMethod methodNode = codegenMethodScope.makeChild(EventBean.class, ExprEvalStreamInsertNamedWindow.class, codegenClassScope); CodegenExpressionRef refEPS = exprSymbol.getAddEPS(methodNode); String method = EventTypeUtility.getAdapterForMethodName(namedWindowAsType); methodNode.getBlock() .declareVar(EventBean.class, "event", arrayAtIndex(refEPS, constant(streamNum))) .ifRefNullReturnNull("event") .methodReturn(exprDotMethod(eventSvc, method, cast(namedWindowAsType.getUnderlyingType(), exprDotUnderlying(ref("event"))), namedWindowType)); return localMethod(methodNode); }
public FilterOp(FilterFactory factory, AgentInstanceContext agentInstanceContext) { this.factory = factory; this.agentInstanceContext = agentInstanceContext; theEvent = EventTypeUtility.getShellForType(factory.getEventType()); eventsPerStream[0] = theEvent; }
PropertySetDescriptor propertySet = EventTypeUtility.getNestableProperties(propertyTypes, beanEventTypeFactory.getEventBeanTypedEventFactory(), getterFactory, optionalSuperTypes, beanEventTypeFactory); propertyDescriptors = propertySet.getPropertyDescriptors().toArray(new EventPropertyDescriptor[propertySet.getPropertyDescriptors().size()]); EventTypeUtility.TimestampPropertyDesc desc = EventTypeUtility.validatedDetermineTimestampProps(this, startTimestampPropertyName, endTimestampPropertyName, optionalSuperTypes); this.startTimestampPropertyName = desc.getStart(); this.endTimestampPropertyName = desc.getEnd();
public BeanEventType(BeanEventTypeStem stem, EventTypeMetadata metadata, BeanEventTypeFactory beanEventTypeFactory, EventType[] superTypes, Set<EventType> deepSuperTypes, String startTimestampPropertyName, String endTimestampPropertyName) { this.stem = stem; this.metadata = metadata; this.beanEventTypeFactory = beanEventTypeFactory; this.superTypes = superTypes; this.deepSuperTypes = deepSuperTypes; EventTypeUtility.TimestampPropertyDesc desc = EventTypeUtility.validatedDetermineTimestampProps(this, startTimestampPropertyName, endTimestampPropertyName, superTypes); this.startTimestampPropertyName = desc.getStart(); this.endTimestampPropertyName = desc.getEnd(); }
Set<WriteablePropertyDescriptor> writablesSet = EventTypeUtility.getWriteableProperties(eventTypeSPI, false, false); List<WriteablePropertyDescriptor> writablePropertiesList = new ArrayList<WriteablePropertyDescriptor>(); List<SimpleTypeParser> parserList = new ArrayList<SimpleTypeParser>(); eventBeanManufacturer = EventTypeUtility.getManufacturer(eventType, writableProperties, runtime.getServicesContext().getClasspathImportServiceRuntime(), false, runtime.getServicesContext().getEventTypeAvroHandler()).getManufacturer(runtime.getServicesContext().getEventBeanTypedEventFactory()); } catch (EventBeanManufactureException e) { log.info("Unable to create manufacturer for event type: " + e.getMessage(), e);
} else if (eventType instanceof WrapperEventType) { WrapperEventType wrapper = (WrapperEventType) eventType; method.getBlock().declareVar(EventType.class, "inner", EventTypeUtility.resolveTypeCodegen(((WrapperEventType) eventType).getUnderlyingEventType(), symbols.getAddInitSvc(method))); method.getBlock().declareVar(LinkedHashMap.class, "props", localMethod(makePropsCodegen(wrapper.getUnderlyingMapType().getTypes(), method, symbols, classScope, () -> wrapper.getUnderlyingMapType().getDeepSuperTypes()))); method.getBlock().expression(exprDotMethodChain(symbols.getAddInitSvc(method)).add(EPModuleEventTypeInitServices.GETEVENTTYPECOLLECTOR).add("registerWrapper", ref("metadata"), ref("inner"), ref("props"))); VariantEventType variantEventType = (VariantEventType) eventType; method.getBlock().expression(exprDotMethodChain(symbols.getAddInitSvc(method)).add(EPModuleEventTypeInitServices.GETEVENTTYPECOLLECTOR).add("registerVariant", ref("metadata"), EventTypeUtility.resolveTypeArrayCodegen(variantEventType.getVariants(), symbols.getAddInitSvc(method)), constant(variantEventType.isVariantAny()))); } else { throw new IllegalStateException("Event type '" + eventType + "' cannot be registered");
Set<WriteablePropertyDescriptor> writables = EventTypeUtility.getWriteableProperties(resultType, true, false); List<Item> items = new ArrayList<Item>(); List<WriteablePropertyDescriptor> written = new ArrayList<WriteablePropertyDescriptor>();
public CodegenMethod makeCodegen(CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbol symbols) { CodegenMethod method = parent.makeChild(MatchedEventMapMeta.class, this.getClass(), classScope); method.getBlock().declareVar(String[].class, "tagsPerIndex", constant(tagsPerIndex)) .declareVar(EventType[].class, "eventTypes", EventTypeUtility.resolveTypeArrayCodegen(eventTypes, symbols.getAddInitSvc(method))) .methodReturn(newInstance(MatchedEventMapMeta.class, ref("tagsPerIndex"), ref("eventTypes"), constant(arrayTags))); return method; }
eventManufacturer = EventTypeUtility.getManufacturer(eventType, writableProperties, classpathImportService, false, eventTypeAvroHandler); } catch (EventBeanManufactureException e) { throw new ExprValidationException(e.getMessage(), e);
public FileSinkCSV(FileSinkFactory factory, String filename, boolean classpathFile, boolean append) { this.factory = factory; this.filename = filename; this.classpathFile = classpathFile; this.append = append; rendererOptions = new RendererMetaOptions(true, false, null, null); rendererMeta = new RendererMeta(factory.getEventType(), new Stack<>(), rendererOptions); eventShell = EventTypeUtility.getShellForType(factory.getEventType()); }
public AvroEventType(EventTypeMetadata metadata, Schema avroSchema, String startTimestampPropertyName, String endTimestampPropertyName, EventType[] optionalSuperTypes, Set<EventType> deepSupertypes, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeAvroHandler eventTypeAvroHandler) { this.metadata = metadata; this.avroSchema = avroSchema; this.optionalSuperTypes = optionalSuperTypes; this.deepSupertypes = deepSupertypes == null ? Collections.emptySet() : deepSupertypes; this.propertyItems = new LinkedHashMap<>(); this.eventBeanTypedEventFactory = eventBeanTypedEventFactory; this.eventTypeAvroHandler = eventTypeAvroHandler; init(); EventTypeUtility.TimestampPropertyDesc desc = EventTypeUtility.validatedDetermineTimestampProps(this, startTimestampPropertyName, endTimestampPropertyName, optionalSuperTypes); this.startTimestampPropertyName = desc.getStart(); this.endTimestampPropertyName = desc.getEnd(); }