public static void buildVariantStreams(EventTypeRepositoryImpl repo, Map<String, ConfigurationCommonVariantStream> variantStreams, EventTypeFactory eventTypeFactory) { for (Map.Entry<String, ConfigurationCommonVariantStream> entry : variantStreams.entrySet()) { if (repo.getTypeByName(entry.getKey()) != null) { continue; } addVariantStream(entry.getKey(), entry.getValue(), repo, eventTypeFactory); } }
public static void buildAvroTypes(EventTypeRepositoryImpl repo, Map<String, ConfigurationCommonEventTypeAvro> eventTypesAvro, EventTypeAvroHandler eventTypeAvroHandler, EventBeanTypedEventFactory eventBeanTypedEventFactory) { for (Map.Entry<String, ConfigurationCommonEventTypeAvro> entry : eventTypesAvro.entrySet()) { if (repo.getTypeByName(entry.getKey()) != null) { continue; } buildAvroType(repo, entry.getKey(), entry.getValue(), eventTypeAvroHandler, eventBeanTypedEventFactory); } }
public static void buildOATypes(EventTypeRepositoryImpl repo, Map<String, ConfigurationCommonEventTypeObjectArray> objectArrayTypeConfigurations, Map<String, Map<String, Object>> nestableObjectArrayNames, BeanEventTypeFactory beanEventTypeFactory, ClasspathImportService classpathImportService) { List<String> creationOrder = EventTypeRepositoryUtil.getCreationOrder(Collections.emptySet(), nestableObjectArrayNames.keySet(), objectArrayTypeConfigurations); for (String objectArrayName : creationOrder) { if (repo.getTypeByName(objectArrayName) != null) { continue; } ConfigurationCommonEventTypeObjectArray objectArrayConfig = objectArrayTypeConfigurations.get(objectArrayName); Map<String, Object> propertyTypes = nestableObjectArrayNames.get(objectArrayName); propertyTypes = resolveClassesForStringPropertyTypes(propertyTypes, classpathImportService); LinkedHashMap<String, Object> propertyTypesCompiled = EventTypeUtility.compileMapTypeProperties(propertyTypes, repo); addNestableObjectArrayType(objectArrayName, propertyTypesCompiled, objectArrayConfig, beanEventTypeFactory, repo); } }
public void mergeFrom(EventTypeRepositoryImpl other) { for (Map.Entry<String, EventType> entry : other.getNameToTypeMap().entrySet()) { if (nameToTypeMap.containsKey(entry.getKey())) { continue; } addType(entry.getValue()); } }
public static void buildMapTypes(EventTypeRepositoryImpl repo, Map<String, ConfigurationCommonEventTypeMap> mapTypeConfigurations, Map<String, Properties> mapTypes, Map<String, Map<String, Object>> nestableMapEvents, BeanEventTypeFactory beanEventTypeFactory, ClasspathImportService classpathImportService) { List<String> creationOrder = EventTypeRepositoryUtil.getCreationOrder(mapTypes.keySet(), nestableMapEvents.keySet(), mapTypeConfigurations); for (String mapName : creationOrder) { if (repo.getTypeByName(mapName) != null) { continue; } ConfigurationCommonEventTypeMap mapConfig = mapTypeConfigurations.get(mapName); Properties propertiesUnnested = mapTypes.get(mapName); if (propertiesUnnested != null) { Map<String, Object> propertyTypes = createPropertyTypes(propertiesUnnested, classpathImportService); LinkedHashMap<String, Object> propertyTypesCompiled = EventTypeUtility.compileMapTypeProperties(propertyTypes, repo); addNestableMapType(mapName, propertyTypesCompiled, mapConfig, repo, beanEventTypeFactory, repo); } Map<String, Object> propertiesNestable = nestableMapEvents.get(mapName); if (propertiesNestable != null) { LinkedHashMap<String, Object> propertiesNestableCompiled = EventTypeUtility.compileMapTypeProperties(propertiesNestable, repo); addNestableMapType(mapName, propertiesNestableCompiled, mapConfig, repo, beanEventTypeFactory, repo); } } }
private EventType resolvePreconfigured(String typeName) { EventType eventType = publics.getTypeByName(typeName); if (eventType == null) { return null; } moduleDependencies.addPublicEventType(typeName); return eventType; }
private static void addVariantStream(String name, ConfigurationCommonVariantStream config, EventTypeRepositoryImpl repo, EventTypeFactory eventTypeFactory) { VariantSpec variantSpec = validateVariantStream(name, config, repo); EventTypeMetadata metadata = new EventTypeMetadata(name, null, EventTypeTypeClass.VARIANT, EventTypeApplicationType.VARIANT, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.BUS, false, new EventTypeIdPair(CRC32Util.computeCRC32(name), -1)); VariantEventType variantEventType = eventTypeFactory.createVariant(metadata, variantSpec); repo.addType(variantEventType); } }
public static EventType getEventTypeForTypeId(StatementContext statementContext, EventTypeIdPair key) { return statementContext.getEventTypeRepositoryPreconfigured().getTypeById(key.getPublicId()); } }
public EventBean adapterForAvro(Object avroGenericDataDotRecord, String eventTypeName) { EventType type = eventTypeRepository.getTypeByName(eventTypeName); EventTypeUtility.validateTypeAvro(eventTypeName, type); return avroHandler.adapterForTypeAvro(avroGenericDataDotRecord, type); }
private static Map<String, Object> createPropertyTypes(Properties properties, ClasspathImportService classpathImportService) { Map<String, Object> propertyTypes = new LinkedHashMap<String, Object>(); for (Map.Entry entry : properties.entrySet()) { String property = (String) entry.getKey(); String className = (String) entry.getValue(); Class clazz = resolveClassForTypeName(className, classpathImportService); if (clazz != null) { propertyTypes.put(property, clazz); } } return propertyTypes; }
private static Map<String, Object> resolveClassesForStringPropertyTypes(Map<String, Object> properties, ClasspathImportService classpathImportService) { Map<String, Object> propertyTypes = new LinkedHashMap<String, Object>(); for (Map.Entry entry : properties.entrySet()) { String property = (String) entry.getKey(); propertyTypes.put(property, entry.getValue()); if (!(entry.getValue() instanceof String)) { continue; } String className = (String) entry.getValue(); Class clazz = resolveClassForTypeName(className, classpathImportService); if (clazz != null) { propertyTypes.put(property, clazz); } } return propertyTypes; }
static void deleteFromEventTypeBus(EPServicesContext services, Map<Long, EventType> eventTypes) { for (Map.Entry<Long, EventType> entry : eventTypes.entrySet()) { if (entry.getValue().getMetadata().getBusModifier() == EventTypeBusModifier.BUS) { services.getEventTypeRepositoryBus().removeType(entry.getValue()); } } }
public EventType getEventTypePreconfigured(String eventTypeName) { return services.getEventTypeRepositoryBus().getTypeByName(eventTypeName); }
public EventType getTypeById(long eventTypeIdPublic, long eventTypeIdProtected) { if (eventTypeIdProtected == -1) { return eventTypeRepositoryPreconfigured.getTypeById(eventTypeIdPublic); } DeploymentInternal deployerResult = deploymentLifecycleService.getDeploymentByCRC(eventTypeIdPublic); return deployerResult.getDeploymentTypes().get(eventTypeIdProtected); } };
public EventBean adapterForMap(Map<String, Object> map, String eventTypeName) { EventType type = eventTypeRepository.getTypeByName(eventTypeName); EventTypeUtility.validateTypeMap(eventTypeName, type); return new MapEventBean(map, type); }
public static EventTypeIdPair getTypeIdForName(StatementContext statementContext, String eventTypeName) { EventType type = statementContext.getEventTypeRepositoryPreconfigured().getTypeByName(eventTypeName); if (type == null) { fail("Type by name '" + eventTypeName + "' not found as a public type"); } return type.getMetadata().getEventTypeIdPair(); }
public EventBean adapterForObjectArray(Object[] theEvent, String eventTypeName) throws EPException { EventType type = eventTypeRepository.getTypeByName(eventTypeName); EventTypeUtility.validateTypeObjectArray(eventTypeName, type); return new ObjectArrayEventBean(theEvent, type); }
private EventType findTypeMayNull(String eventTypeName) { EventType eventType = eventTypeRepositoryPreconfigured.getTypeByName(eventTypeName); if (eventType != null) { return eventType; } try { eventType = pathEventTypes.getAnyModuleExpectSingle(eventTypeName, null).getFirst(); } catch (PathException ex) { throw new EPException("Failed to obtain event type '" + eventTypeName + "': " + ex.getMessage(), ex); } return eventType; } }
public EventBean adapterForBean(Object data, String eventTypeName) { EventType type = eventTypeRepository.getTypeByName(eventTypeName); EventTypeUtility.validateTypeBean(eventTypeName, type); return new BeanEventBean(data, type); }
public EventBean adapterForXMLDOM(org.w3c.dom.Node node, String eventTypeName) { EventType type = eventTypeRepository.getTypeByName(eventTypeName); EventTypeUtility.validateTypeXMLDOM(eventTypeName, type); org.w3c.dom.Node namedNode = getXMLNodeFromDocument(node); return new XMLEventBean(namedNode, type); }