public EventBean makeAdapter(Object underlying) { return eventBeanTypedEventFactory.adapterForTypedBean(underlying, eventType); } }
public EventBean copy(EventBean theEvent) { MappedEventBean mapped = (MappedEventBean) theEvent; Map<String, Object> props = mapped.getProperties(); return eventBeanTypedEventFactory.adapterForTypedMap(new HashMap<String, Object>(props), mapEventType); }
public EventBean adapterForTypedAvro(Object avroGenericDataDotRecord, EventType eventType) { return typedEventFactory.adapterForTypedAvro(avroGenericDataDotRecord, eventType); }
/** * NOTE: Code-generation-invoked method, method name and parameter order matters * * @param fragmentUnderlying fragment * @param fragmentEventType type * @param eventBeanTypedEventFactory svc * @return bean */ public static EventBean getBNFragmentNonPojo(Object fragmentUnderlying, EventType fragmentEventType, EventBeanTypedEventFactory eventBeanTypedEventFactory) { if (fragmentUnderlying == null) { return null; } if (fragmentEventType instanceof MapEventType) { return eventBeanTypedEventFactory.adapterForTypedMap((Map<String, Object>) fragmentUnderlying, fragmentEventType); } return eventBeanTypedEventFactory.adapterForTypedObjectArray((Object[]) fragmentUnderlying, fragmentEventType); }
public EventBean wrap(Object underlying) { EventBean bean = eventBeanTypedEventFactory.adapterForTypedBean(underlying, beanEventType); return eventBeanTypedEventFactory.adapterForTypedWrapper(bean, Collections.<String, Object>emptyMap(), wrapperEventType); }
props.put(propDesc.getPropertyName(), wrapper.getUnderlyingEvent().get(propDesc.getPropertyName())); converted = eventAdapterService.adapterForTypedMap(props, targetType); } else { converted = eventAdapterService.adapterForTypedWrapper(wrapper.getUnderlyingEvent(), wrapper.getDecoratingProperties(), targetType); converted = eventAdapterService.adapterForTypedMap(mapEvent.getProperties(), targetType); } else if ((theEvent.getEventType() instanceof MapEventType) && (targetType instanceof WrapperEventType)) { converted = eventAdapterService.adapterForTypedWrapper(theEvent, Collections.EMPTY_MAP, targetType); } else if ((theEvent.getEventType() instanceof BeanEventType) && (targetType instanceof BeanEventType)) { converted = eventAdapterService.adapterForTypedBean(theEvent.getUnderlying(), targetType); } else if (theEvent.getEventType() instanceof ObjectArrayEventType && targetType instanceof ObjectArrayEventType) { Object[] convertedObjectArray = ObjectArrayEventType.convertEvent(theEvent, (ObjectArrayEventType) targetType); converted = eventAdapterService.adapterForTypedObjectArray(convertedObjectArray, targetType); } else if (theEvent.getEventType() instanceof AvroSchemaEventType && targetType instanceof AvroSchemaEventType) { Object convertedGenericRecord = eventTypeAvroHandler.convertEvent(theEvent, (AvroSchemaEventType) targetType); converted = eventAdapterService.adapterForTypedAvro(convertedGenericRecord, targetType); } else { throw new EPException("Unknown event type " + theEvent.getEventType());
return runtime.getServicesContext().getEventBeanTypedEventFactory().adapterForTypedBean(obj, eventType); } else if (message instanceof MapMessage) { Map<String, Object> properties = new HashMap<String, Object>(); return runtime.getServicesContext().getEventBeanTypedEventFactory().adapterForTypedMap(properties, eventType); } else { String error = ".unmarshal Failed to unmarshal message of JMS type: " + message.getJMSType();
public EventBean makeAdapter(Object underlying) { return eventBeanTypedEventFactory.adapterForTypedObjectArray((Object[]) underlying, eventType); } }
public EventBean makeAdapter(Object underlying) { return eventBeanTypedEventFactory.adapterForTypedDOM((Node) underlying, eventType); } }
/** * NOTE: Code-generation-invoked method, method name and parameter order matters * * @param props props * @param eventsPerStream events * @param emptyExpressions flag * @param eventBeanTypedEventFactory svc * @param resultEventType type * @return bean */ public static EventBean processSelectExprSSWrapper(Map<String, Object> props, EventBean[] eventsPerStream, boolean emptyExpressions, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventType resultEventType) { EventBean theEvent = eventsPerStream[0]; return eventBeanTypedEventFactory.adapterForTypedWrapper(theEvent, props, resultEventType); } }
public EventBean wrap(Object underlying) { return eventBeanTypedEventFactory.adapterForTypedObjectArray((Object[]) underlying, type); }
public EventBean wrap(Object underlying) { return eventBeanTypedEventFactory.adapterForTypedDOM((Node) underlying, type); }
public static EventBean wildcardNestedWrapper(EventBean event, EventType innerWrapperType, EventType outerWrapperType, EventBeanTypedEventFactory factory, Map<String, Object> props) { EventBean inner = factory.adapterForTypedWrapper(event, Collections.emptyMap(), innerWrapperType); return factory.adapterForTypedWrapper(inner, props, outerWrapperType); } }
public void matchFound(Map<String, Object> matchEvent, EventBean optionalTriggeringEvent) { EventBean compositeEvent = eventBeanTypedEventFactory.adapterForTypedMap(matchEvent, eventType); sourceEventStream.insert(compositeEvent); } };
public EventBean adapterForTypedBean(Object bean, EventType eventType) { return typedEventFactory.adapterForTypedBean(bean, eventType); }
public EventBean wrap(Object underlying) { return eventAdapterService.adapterForTypedAvro(underlying, type); }
public EventBean adapterForTypedObjectArray(Object[] props, EventType eventType) { return typedEventFactory.adapterForTypedObjectArray(props, eventType); }
public EventBean adapterForTypedDOM(Node node, EventType eventType) { return typedEventFactory.adapterForTypedDOM(node, eventType); }
public EventBean copy(EventBean theEvent) { DecoratingEventBean decorated = (DecoratingEventBean) theEvent; EventBean decoratedUnderlying = decorated.getUnderlyingEvent(); Map<String, Object> copiedMap = new HashMap<String, Object>(decorated.getDecoratingProperties()); return eventAdapterService.adapterForTypedWrapper(decoratedUnderlying, copiedMap, wrapperEventType); } }
public EventBean copy(EventBean theEvent) { MappedEventBean mapped = (MappedEventBean) theEvent; Map<String, Object> props = mapped.getProperties(); return eventAdapterService.adapterForTypedMap(new HashMap<>(props), mapEventType); } }