public void addEventType(Class javaEventClass) {
try {
eventAdapterService.addBeanType(
javaEventClass.getSimpleName(), javaEventClass, false, true, true);
} catch (EventAdapterException t) {
throw new ConfigurationException(t.getMessage(), t);
}
}
public SelectExprProcessor getEvaluator() throws ExprValidationException {
// Get the named and un-named stream selectors (i.e. select s0.* from S0 as s0), if any
List<SelectClauseStreamCompiledSpec> namedStreams =
new ArrayList<SelectClauseStreamCompiledSpec>();
List<SelectExprStreamDesc> unnamedStreams = new ArrayList<SelectExprStreamDesc>();
for (SelectExprStreamDesc spec : selectedStreams) {
if (spec.getStreamSelected() != null && spec.getStreamSelected().getOptionalName() == null) {
unnamedStreams.add(spec);
} else if (spec.getExpressionSelectedAsStream()
!= null) { // handle special "transpose(...)" function
unnamedStreams.add(spec);
} else {
namedStreams.add(spec.getStreamSelected());
if (spec.getStreamSelected().isProperty()) {
throw new ExprValidationException(
"The property wildcard syntax must be used without column name");
}
}
}
// Error if there are more then one un-named streams (i.e. select s0.*, s1.* from S0 as s0, S1
// as s1)
// Thus there is only 1 unnamed stream selector maximum.
if (unnamedStreams.size() > 1) {
throw new ExprValidationException(
"A column name must be supplied for all but one stream if multiple streams are selected via the stream.* notation");
}
if (selectedStreams.isEmpty() && selectionList.isEmpty() && !isUsingWildcard) {
throw new IllegalArgumentException("Empty selection list not supported");
}
for (SelectClauseExprCompiledSpec entry : selectionList) {
if (entry.getAssignedName() == null) {
throw new IllegalArgumentException(
"Expected name for each expression has not been supplied");
}
}
// Verify insert into clause
if (insertIntoDesc != null) {
verifyInsertInto(insertIntoDesc, selectionList);
}
// Build a subordinate wildcard processor for joins
SelectExprProcessor joinWildcardProcessor = null;
if (typeService.getStreamNames().length > 1 && isUsingWildcard) {
joinWildcardProcessor =
SelectExprJoinWildcardProcessorFactory.create(
assignedTypeNumberStack,
statementId,
typeService.getStreamNames(),
typeService.getEventTypes(),
eventAdapterService,
null,
selectExprEventTypeRegistry,
methodResolutionService,
annotations,
configuration);
}
// Resolve underlying event type in the case of wildcard select
EventType eventType = null;
boolean singleStreamWrapper = false;
if (isUsingWildcard) {
if (joinWildcardProcessor != null) {
eventType = joinWildcardProcessor.getResultEventType();
} else {
eventType = typeService.getEventTypes()[0];
if (eventType instanceof WrapperEventType) {
singleStreamWrapper = true;
}
}
}
// Get expression nodes
ExprEvaluator[] exprEvaluators = new ExprEvaluator[selectionList.size()];
ExprNode[] exprNodes = new ExprNode[selectionList.size()];
Object[] expressionReturnTypes = new Object[selectionList.size()];
for (int i = 0; i < selectionList.size(); i++) {
ExprNode expr = selectionList.get(i).getSelectExpression();
exprNodes[i] = expr;
exprEvaluators[i] = expr.getExprEvaluator();
Map<String, Object> eventTypeExpr = exprEvaluators[i].getEventType();
if (eventTypeExpr == null) {
expressionReturnTypes[i] = exprEvaluators[i].getType();
} else {
final ExprEvaluator innerExprEvaluator = expr.getExprEvaluator();
final EventType mapType =
eventAdapterService.createAnonymousMapType(
statementId
+ "_innereval_"
+ CollectionUtil.toString(assignedTypeNumberStack, "_")
+ "_"
+ i,
eventTypeExpr);
ExprEvaluator evaluatorFragment =
new ExprEvaluator() {
public Object evaluate(
EventBean[] eventsPerStream,
boolean isNewData,
ExprEvaluatorContext exprEvaluatorContext) {
Map<String, Object> values =
(Map<String, Object>)
innerExprEvaluator.evaluate(
eventsPerStream, isNewData, exprEvaluatorContext);
if (values == null) {
values = Collections.emptyMap();
}
return eventAdapterService.adapterForTypedMap(values, mapType);
}
public Class getType() {
return Map.class;
}
public Map<String, Object> getEventType() {
return null;
}
};
expressionReturnTypes[i] = mapType;
exprEvaluators[i] = evaluatorFragment;
}
}
// Get column names
String[] columnNames;
String[] columnNamesAsProvided;
if ((insertIntoDesc != null) && (!insertIntoDesc.getColumnNames().isEmpty())) {
columnNames =
insertIntoDesc
.getColumnNames()
.toArray(new String[insertIntoDesc.getColumnNames().size()]);
columnNamesAsProvided = columnNames;
} else if (!selectedStreams.isEmpty()) { // handle stream selection column names
int numStreamColumnsJoin = 0;
if (isUsingWildcard && typeService.getEventTypes().length > 1) {
numStreamColumnsJoin = typeService.getEventTypes().length;
}
columnNames = new String[selectionList.size() + namedStreams.size() + numStreamColumnsJoin];
columnNamesAsProvided = new String[columnNames.length];
int count = 0;
for (SelectClauseExprCompiledSpec aSelectionList : selectionList) {
columnNames[count] = aSelectionList.getAssignedName();
columnNamesAsProvided[count] = aSelectionList.getProvidedName();
count++;
}
for (SelectClauseStreamCompiledSpec aSelectionList : namedStreams) {
columnNames[count] = aSelectionList.getOptionalName();
columnNamesAsProvided[count] = aSelectionList.getOptionalName();
count++;
}
// for wildcard joins, add the streams themselves
if (isUsingWildcard && typeService.getEventTypes().length > 1) {
for (String streamName : typeService.getStreamNames()) {
columnNames[count] = streamName;
columnNamesAsProvided[count] = streamName;
count++;
}
}
} else // handle regular column names
{
columnNames = new String[selectionList.size()];
columnNamesAsProvided = new String[selectionList.size()];
for (int i = 0; i < selectionList.size(); i++) {
columnNames[i] = selectionList.get(i).getAssignedName();
columnNamesAsProvided[i] = selectionList.get(i).getProvidedName();
}
}
// Find if there is any fragments selected
EventType targetType = null;
if (insertIntoDesc != null) {
targetType = eventAdapterService.getExistsTypeByName(insertIntoDesc.getEventTypeName());
}
// Find if there is any fragment event types:
// This is a special case for fragments: select a, b from pattern [a=A -> b=B]
// We'd like to maintain 'A' and 'B' EventType in the Map type, and 'a' and 'b' EventBeans in
// the event bean
for (int i = 0; i < selectionList.size(); i++) {
if (!(exprNodes[i] instanceof ExprIdentNode)) {
continue;
}
ExprIdentNode identNode = (ExprIdentNode) exprNodes[i];
String propertyName = identNode.getResolvedPropertyName();
final int streamNum = identNode.getStreamId();
EventType eventTypeStream = typeService.getEventTypes()[streamNum];
if (eventTypeStream instanceof NativeEventType) {
continue; // we do not transpose the native type for performance reasons
}
FragmentEventType fragmentType = eventTypeStream.getFragmentType(propertyName);
if ((fragmentType == null) || (fragmentType.isNative())) {
continue; // we also ignore native Java classes as fragments for performance reasons
}
// may need to unwrap the fragment if the target type has this underlying type
FragmentEventType targetFragment = null;
if (targetType != null) {
targetFragment = targetType.getFragmentType(columnNames[i]);
}
if ((targetType != null)
&& (fragmentType.getFragmentType().getUnderlyingType() == expressionReturnTypes[i])
&& ((targetFragment == null) || (targetFragment != null && targetFragment.isNative()))) {
ExprEvaluator evaluatorFragment;
// A match was found, we replace the expression
final EventPropertyGetter getter = eventTypeStream.getGetter(propertyName);
final Class returnType = eventTypeStream.getPropertyType(propertyName);
evaluatorFragment =
new ExprEvaluator() {
public Object evaluate(
EventBean[] eventsPerStream,
boolean isNewData,
ExprEvaluatorContext exprEvaluatorContext) {
EventBean streamEvent = eventsPerStream[streamNum];
if (streamEvent == null) {
return null;
}
return getter.get(streamEvent);
}
public Class getType() {
return returnType;
}
@Override
public Map<String, Object> getEventType() {
return null;
}
};
exprEvaluators[i] = evaluatorFragment;
}
// same for arrays: may need to unwrap the fragment if the target type has this underlying
// type
else if ((targetType != null)
&& expressionReturnTypes[i] instanceof Class
&& (fragmentType.getFragmentType().getUnderlyingType()
== ((Class) expressionReturnTypes[i]).getComponentType())
&& ((targetFragment == null) || (targetFragment != null && targetFragment.isNative()))) {
ExprEvaluator evaluatorFragment;
final EventPropertyGetter getter = eventTypeStream.getGetter(propertyName);
final Class returnType =
JavaClassHelper.getArrayType(eventTypeStream.getPropertyType(propertyName));
evaluatorFragment =
new ExprEvaluator() {
public Object evaluate(
EventBean[] eventsPerStream,
boolean isNewData,
ExprEvaluatorContext exprEvaluatorContext) {
EventBean streamEvent = eventsPerStream[streamNum];
if (streamEvent == null) {
return null;
}
return getter.get(streamEvent);
}
public Class getType() {
return returnType;
}
@Override
public Map<String, Object> getEventType() {
return null;
}
};
exprEvaluators[i] = evaluatorFragment;
} else {
ExprEvaluator evaluatorFragment;
final EventPropertyGetter getter = eventTypeStream.getGetter(propertyName);
final Class returnType =
eventTypeStream.getFragmentType(propertyName).getFragmentType().getUnderlyingType();
// A match was found, we replace the expression
evaluatorFragment =
new ExprEvaluator() {
public Object evaluate(
EventBean[] eventsPerStream,
boolean isNewData,
ExprEvaluatorContext exprEvaluatorContext) {
EventBean streamEvent = eventsPerStream[streamNum];
if (streamEvent == null) {
return null;
}
return getter.getFragment(streamEvent);
}
public Class getType() {
return returnType;
}
public Map<String, Object> getEventType() {
return null;
}
};
exprEvaluators[i] = evaluatorFragment;
if (!fragmentType.isIndexed()) {
expressionReturnTypes[i] = fragmentType.getFragmentType();
} else {
expressionReturnTypes[i] = new EventType[] {fragmentType.getFragmentType()};
}
}
}
// Find if there is any stream expression (ExprStreamNode) :
// This is a special case for stream selection: select a, b from A as a, B as b
// We'd like to maintain 'A' and 'B' EventType in the Map type, and 'a' and 'b' EventBeans in
// the event bean
for (int i = 0; i < selectionList.size(); i++) {
if (!(exprEvaluators[i] instanceof ExprStreamUnderlyingNode)) {
continue;
}
ExprStreamUnderlyingNode undNode = (ExprStreamUnderlyingNode) exprEvaluators[i];
final int streamNum = undNode.getStreamId();
final Class returnType = undNode.getExprEvaluator().getType();
EventType eventTypeStream = typeService.getEventTypes()[streamNum];
// A match was found, we replace the expression
ExprEvaluator evaluator =
new ExprEvaluator() {
public Object evaluate(
EventBean[] eventsPerStream,
boolean isNewData,
ExprEvaluatorContext exprEvaluatorContext) {
return eventsPerStream[streamNum];
}
public Class getType() {
return returnType;
}
public Map<String, Object> getEventType() {
return null;
}
};
exprEvaluators[i] = evaluator;
expressionReturnTypes[i] = eventTypeStream;
}
// Build event type that reflects all selected properties
Map<String, Object> selPropertyTypes = new LinkedHashMap<String, Object>();
int count = 0;
for (int i = 0; i < exprEvaluators.length; i++) {
Object expressionReturnType = expressionReturnTypes[count];
selPropertyTypes.put(columnNames[count], expressionReturnType);
count++;
}
if (!selectedStreams.isEmpty()) {
for (SelectClauseStreamCompiledSpec element : namedStreams) {
EventType eventTypeStream = typeService.getEventTypes()[element.getStreamNumber()];
selPropertyTypes.put(columnNames[count], eventTypeStream);
count++;
}
if (isUsingWildcard && typeService.getEventTypes().length > 1) {
for (int i = 0; i < typeService.getEventTypes().length; i++) {
EventType eventTypeStream = typeService.getEventTypes()[i];
selPropertyTypes.put(columnNames[count], eventTypeStream);
count++;
}
}
}
// Handle stream selection
EventType underlyingEventType = null;
int underlyingStreamNumber = 0;
boolean underlyingIsFragmentEvent = false;
EventPropertyGetter underlyingPropertyEventGetter = null;
ExprEvaluator underlyingExprEvaluator = null;
boolean useMapOutput =
EventRepresentationUtil.isMap(
annotations, configuration, CreateSchemaDesc.AssignedType.NONE);
if (!selectedStreams.isEmpty()) {
// Resolve underlying event type in the case of wildcard or non-named stream select.
// Determine if the we are considering a tagged event or a stream name.
if ((isUsingWildcard) || (!unnamedStreams.isEmpty())) {
if (!unnamedStreams.isEmpty()) {
if (unnamedStreams.get(0).getStreamSelected() != null) {
SelectClauseStreamCompiledSpec streamSpec = unnamedStreams.get(0).getStreamSelected();
// the tag.* syntax for : select tag.* from pattern [tag = A]
underlyingStreamNumber = streamSpec.getStreamNumber();
if (streamSpec.isFragmentEvent()) {
EventType compositeMap = typeService.getEventTypes()[underlyingStreamNumber];
FragmentEventType fragment = compositeMap.getFragmentType(streamSpec.getStreamName());
underlyingEventType = fragment.getFragmentType();
underlyingIsFragmentEvent = true;
}
// the property.* syntax for : select property.* from A
else if (streamSpec.isProperty()) {
String propertyName = streamSpec.getStreamName();
Class propertyType = streamSpec.getPropertyType();
int streamNumber = streamSpec.getStreamNumber();
if (JavaClassHelper.isJavaBuiltinDataType(streamSpec.getPropertyType())) {
throw new ExprValidationException(
"The property wildcard syntax cannot be used on built-in types as returned by property '"
+ propertyName
+ "'");
}
// create or get an underlying type for that Class
underlyingEventType =
eventAdapterService.addBeanType(
propertyType.getName(), propertyType, false, false, false);
selectExprEventTypeRegistry.add(underlyingEventType);
underlyingPropertyEventGetter =
typeService.getEventTypes()[streamNumber].getGetter(propertyName);
if (underlyingPropertyEventGetter == null) {
throw new ExprValidationException(
"Unexpected error resolving property getter for property " + propertyName);
}
}
// the stream.* syntax for: select a.* from A as a
else {
underlyingEventType = typeService.getEventTypes()[underlyingStreamNumber];
}
}
// handle case where the unnamed stream is a "transpose" function
else {
ExprNode expression =
unnamedStreams.get(0).getExpressionSelectedAsStream().getSelectExpression();
Class returnType = expression.getExprEvaluator().getType();
underlyingEventType =
eventAdapterService.addBeanType(
returnType.getName(), returnType, false, false, false);
selectExprEventTypeRegistry.add(underlyingEventType);
underlyingExprEvaluator = expression.getExprEvaluator();
}
} else {
// no un-named stream selectors, but a wildcard was specified
if (typeService.getEventTypes().length == 1) {
// not a join, we are using the selected event
underlyingEventType = typeService.getEventTypes()[0];
if (underlyingEventType instanceof WrapperEventType) {
singleStreamWrapper = true;
}
} else {
// For joins, all results are placed in a map with properties for each stream
underlyingEventType = null;
}
}
}
}
SelectExprContext selectExprContext =
new SelectExprContext(exprEvaluators, columnNames, eventAdapterService);
if (insertIntoDesc == null) {
if (!selectedStreams.isEmpty()) {
EventType resultEventType;
if (underlyingEventType != null) {
resultEventType =
eventAdapterService.createAnonymousWrapperType(
statementId + "_wrapout_" + CollectionUtil.toString(assignedTypeNumberStack, "_"),
underlyingEventType,
selPropertyTypes);
return new EvalSelectStreamWUnderlying(
selectExprContext,
resultEventType,
namedStreams,
isUsingWildcard,
unnamedStreams,
singleStreamWrapper,
underlyingIsFragmentEvent,
underlyingStreamNumber,
underlyingPropertyEventGetter,
underlyingExprEvaluator);
} else {
resultEventType =
eventAdapterService.createAnonymousMapType(
statementId + "_mapout_" + CollectionUtil.toString(assignedTypeNumberStack, "_"),
selPropertyTypes);
return new EvalSelectStreamNoUnderlyingMap(
selectExprContext, resultEventType, namedStreams, isUsingWildcard);
}
}
if (isUsingWildcard) {
EventType resultEventType =
eventAdapterService.createAnonymousWrapperType(
statementId
+ "_wrapoutwild_"
+ CollectionUtil.toString(assignedTypeNumberStack, "_"),
eventType,
selPropertyTypes);
if (singleStreamWrapper) {
return new EvalSelectWildcardSSWrapper(selectExprContext, resultEventType);
}
if (joinWildcardProcessor == null) {
return new EvalSelectWildcard(selectExprContext, resultEventType);
}
return new EvalSelectWildcardJoin(
selectExprContext, resultEventType, joinWildcardProcessor);
}
EventType resultEventType;
if (!useMapOutput) {
resultEventType =
eventAdapterService.createAnonymousObjectArrayType(
statementId + "_result_" + CollectionUtil.toString(assignedTypeNumberStack, "_"),
selPropertyTypes);
} else {
resultEventType =
eventAdapterService.createAnonymousMapType(
statementId + "_result_" + CollectionUtil.toString(assignedTypeNumberStack, "_"),
selPropertyTypes);
}
if (selectExprContext.getExpressionNodes().length == 0) {
return new EvalSelectNoWildcardEmptyProps(selectExprContext, resultEventType);
} else {
if (!useMapOutput) {
return new EvalSelectNoWildcardObjectArray(selectExprContext, resultEventType);
}
return new EvalSelectNoWildcardMap(selectExprContext, resultEventType);
}
}
EventType vaeInnerEventType = null;
boolean singleColumnWrapOrBeanCoercion =
false; // Additional single-column coercion for non-wrapped type done by
// SelectExprInsertEventBeanFactory
boolean isRevisionEvent = false;
try {
if (!selectedStreams.isEmpty()) {
EventType resultEventType;
if (underlyingEventType
!= null) // a single stream was selected via "stream.*" and there is no column name
{
// recast as a Map-type
if (underlyingEventType instanceof MapEventType && targetType instanceof MapEventType) {
return new EvalSelectStreamWUnderlyingRecastMap(
selectExprContext,
selectedStreams.get(0).getStreamSelected().getStreamNumber(),
targetType);
}
// recast as a Object-array-type
if (underlyingEventType instanceof ObjectArrayEventType
&& targetType instanceof ObjectArrayEventType) {
return new EvalSelectStreamWUnderlyingRecastObjectArray(
selectExprContext,
selectedStreams.get(0).getStreamSelected().getStreamNumber(),
targetType);
}
// recast as a Bean-type
if (underlyingEventType instanceof BeanEventType && targetType instanceof BeanEventType) {
SelectClauseExprCompiledSpec expressionAsStream =
selectedStreams.get(0).getExpressionSelectedAsStream();
if (expressionAsStream != null) {
return new EvalSelectStreamWUnderlyingRecastBean(
selectExprContext,
expressionAsStream,
underlyingEventType,
targetType,
exprEvaluators.length);
} else {
return new EvalInsertBeanRecast(
targetType,
eventAdapterService,
selectedStreams.get(0).getStreamSelected().getStreamNumber(),
typeService.getEventTypes());
}
}
// wrap if no recast possible
resultEventType =
eventAdapterService.addWrapperType(
insertIntoDesc.getEventTypeName(),
underlyingEventType,
selPropertyTypes,
false,
true);
return new EvalSelectStreamWUnderlying(
selectExprContext,
resultEventType,
namedStreams,
isUsingWildcard,
unnamedStreams,
singleStreamWrapper,
underlyingIsFragmentEvent,
underlyingStreamNumber,
underlyingPropertyEventGetter,
underlyingExprEvaluator);
} else // there are one or more streams selected with column name such as "stream.* as
// columnOne"
{
EventType existingType =
eventAdapterService.getExistsTypeByName(insertIntoDesc.getEventTypeName());
if (existingType instanceof BeanEventType) {
String name = selectedStreams.get(0).getStreamSelected().getStreamName();
String alias = selectedStreams.get(0).getStreamSelected().getOptionalName();
String syntaxUsed = name + ".*" + (alias != null ? " as " + alias : "");
String syntaxInstead = name + (alias != null ? " as " + alias : "");
throw new ExprValidationException(
"The '"
+ syntaxUsed
+ "' syntax is not allowed when inserting into an existing bean event type, use the '"
+ syntaxInstead
+ "' syntax instead");
}
if (existingType == null || existingType instanceof MapEventType) {
resultEventType =
eventAdapterService.addNestableMapType(
insertIntoDesc.getEventTypeName(),
selPropertyTypes,
null,
false,
false,
false,
false,
true);
Set<String> propertiesToUnwrap =
getEventBeanToObjectProps(selPropertyTypes, resultEventType);
if (propertiesToUnwrap.isEmpty()) {
return new EvalSelectStreamNoUnderlyingMap(
selectExprContext, resultEventType, namedStreams, isUsingWildcard);
} else {
return new EvalSelectStreamNoUndWEventBeanToObj(
selectExprContext,
resultEventType,
namedStreams,
isUsingWildcard,
propertiesToUnwrap);
}
} else {
Set<String> propertiesToUnwrap =
getEventBeanToObjectProps(selPropertyTypes, existingType);
if (propertiesToUnwrap.isEmpty()) {
return new EvalSelectStreamNoUnderlyingObjectArray(
selectExprContext, existingType, namedStreams, isUsingWildcard);
} else {
return new EvalSelectStreamNoUndWEventBeanToObjObjArray(
selectExprContext,
existingType,
namedStreams,
isUsingWildcard,
propertiesToUnwrap);
}
}
}
}
ValueAddEventProcessor vaeProcessor =
valueAddEventService.getValueAddProcessor(insertIntoDesc.getEventTypeName());
EventType resultEventType;
if (isUsingWildcard) {
if (vaeProcessor != null) {
resultEventType = vaeProcessor.getValueAddEventType();
isRevisionEvent = true;
vaeProcessor.validateEventType(eventType);
} else {
EventType existingType =
eventAdapterService.getExistsTypeByName(insertIntoDesc.getEventTypeName());
SelectExprProcessor existingTypeProcessor = null;
if (existingType != null) {
// we may get away with re-casting an existing bean-event-type event to another
// bean-event-type
if ((existingType instanceof BeanEventType)
&& (typeService.getEventTypes()[0] instanceof BeanEventType)
&& (selPropertyTypes.isEmpty())) {
return new EvalInsertBeanRecast(
existingType, eventAdapterService, 0, typeService.getEventTypes());
}
if ((existingType instanceof WrapperEventType)
&& (typeService.getEventTypes()[0] instanceof BeanEventType)
&& (exprEvaluators.length == 0)) {
WrapperEventType wrapperType = (WrapperEventType) existingType;
if (wrapperType.getUnderlyingEventType() instanceof BeanEventType) {
return new EvalInsertBeanWrapRecast(
wrapperType, eventAdapterService, 0, typeService.getEventTypes());
}
}
existingTypeProcessor =
SelectExprInsertEventBeanFactory.getInsertUnderlyingNonJoin(
eventAdapterService,
existingType,
isUsingWildcard,
typeService,
exprEvaluators,
columnNames,
expressionReturnTypes,
methodResolutionService.getEngineImportService(),
insertIntoDesc,
columnNamesAsProvided);
}
if (existingTypeProcessor != null) {
return existingTypeProcessor;
} else if (existingType != null
&& selPropertyTypes.isEmpty()
&& existingType instanceof MapEventType) {
resultEventType = existingType;
return new EvalInsertCoercionMap(resultEventType, eventAdapterService);
} else if (existingType != null
&& selPropertyTypes.isEmpty()
&& existingType instanceof ObjectArrayEventType) {
resultEventType = existingType;
return new EvalInsertCoercionObjectArray(resultEventType, eventAdapterService);
} else if (selPropertyTypes.isEmpty() && eventType instanceof BeanEventType) {
BeanEventType beanEventType = (BeanEventType) eventType;
resultEventType =
eventAdapterService.addBeanTypeByName(
insertIntoDesc.getEventTypeName(), beanEventType.getUnderlyingType(), false);
} else {
resultEventType =
eventAdapterService.addWrapperType(
insertIntoDesc.getEventTypeName(), eventType, selPropertyTypes, false, true);
}
}
if (singleStreamWrapper) {
if (!isRevisionEvent) {
return new EvalInsertWildcardSSWrapper(selectExprContext, resultEventType);
} else {
return new EvalInsertWildcardSSWrapperRevision(
selectExprContext, resultEventType, vaeProcessor);
}
}
if (joinWildcardProcessor == null) {
if (!isRevisionEvent) {
if (resultEventType instanceof WrapperEventType) {
return new EvalInsertWildcardWrapper(selectExprContext, resultEventType);
} else {
return new EvalInsertWildcardBean(selectExprContext, resultEventType);
}
} else {
if (exprEvaluators.length == 0) {
return new EvalInsertWildcardRevision(
selectExprContext, resultEventType, vaeProcessor);
} else {
EventType wrappingEventType =
eventAdapterService.addWrapperType(
insertIntoDesc.getEventTypeName() + "_wrapped",
eventType,
selPropertyTypes,
false,
true);
return new EvalInsertWildcardRevisionWrapper(
selectExprContext, resultEventType, vaeProcessor, wrappingEventType);
}
}
} else {
if (!isRevisionEvent) {
return new EvalInsertWildcardJoin(
selectExprContext, resultEventType, joinWildcardProcessor);
} else {
return new EvalInsertWildcardJoinRevision(
selectExprContext, resultEventType, joinWildcardProcessor, vaeProcessor);
}
}
}
// not using wildcard
resultEventType = null;
if ((columnNames.length == 1) && (insertIntoDesc.getColumnNames().size() == 0)) {
EventType existingType =
eventAdapterService.getExistsTypeByName(insertIntoDesc.getEventTypeName());
if (existingType != null) {
// check if the existing type and new type are compatible
Object columnOneType = expressionReturnTypes[0];
if (existingType instanceof WrapperEventType) {
WrapperEventType wrapperType = (WrapperEventType) existingType;
// Map and Object both supported
if (wrapperType.getUnderlyingEventType().getUnderlyingType() == columnOneType) {
singleColumnWrapOrBeanCoercion = true;
resultEventType = existingType;
}
}
if ((existingType instanceof BeanEventType) && (columnOneType instanceof Class)) {
BeanEventType beanType = (BeanEventType) existingType;
// Map and Object both supported
if (JavaClassHelper.isSubclassOrImplementsInterface(
(Class) columnOneType, beanType.getUnderlyingType())) {
singleColumnWrapOrBeanCoercion = true;
resultEventType = existingType;
}
}
}
}
if (singleColumnWrapOrBeanCoercion) {
if (!isRevisionEvent) {
if (resultEventType instanceof WrapperEventType) {
WrapperEventType wrapper = (WrapperEventType) resultEventType;
if (wrapper.getUnderlyingEventType() instanceof MapEventType) {
return new EvalInsertNoWildcardSingleColCoercionMapWrap(
selectExprContext, resultEventType);
} else if (wrapper.getUnderlyingEventType() instanceof ObjectArrayEventType) {
return new EvalInsertNoWildcardSingleColCoercionObjectArrayWrap(
selectExprContext, resultEventType);
} else if (wrapper.getUnderlyingEventType() instanceof VariantEventType) {
VariantEventType variantEventType =
(VariantEventType) wrapper.getUnderlyingEventType();
vaeProcessor = valueAddEventService.getValueAddProcessor(variantEventType.getName());
return new EvalInsertNoWildcardSingleColCoercionBeanWrapVariant(
selectExprContext, resultEventType, vaeProcessor);
} else {
return new EvalInsertNoWildcardSingleColCoercionBeanWrap(
selectExprContext, resultEventType);
}
} else {
if (resultEventType instanceof BeanEventType) {
return new EvalInsertNoWildcardSingleColCoercionBean(
selectExprContext, resultEventType);
}
}
} else {
if (resultEventType instanceof MapEventType) {
return new EvalInsertNoWildcardSingleColCoercionRevisionMap(
selectExprContext, resultEventType, vaeProcessor, vaeInnerEventType);
} else if (resultEventType instanceof ObjectArrayEventType) {
return new EvalInsertNoWildcardSingleColCoercionRevisionObjectArray(
selectExprContext, resultEventType, vaeProcessor, vaeInnerEventType);
} else if (resultEventType instanceof BeanEventType) {
return new EvalInsertNoWildcardSingleColCoercionRevisionBean(
selectExprContext, resultEventType, vaeProcessor, vaeInnerEventType);
} else {
return new EvalInsertNoWildcardSingleColCoercionRevisionBeanWrap(
selectExprContext, resultEventType, vaeProcessor, vaeInnerEventType);
}
}
}
if (resultEventType == null) {
if (vaeProcessor != null) {
// Use an anonymous type if the target is not a variant stream
if (valueAddEventService.getValueAddProcessor(insertIntoDesc.getEventTypeName())
== null) {
resultEventType =
eventAdapterService.createAnonymousMapType(
statementId + "_vae_" + CollectionUtil.toString(assignedTypeNumberStack, "_"),
selPropertyTypes);
} else {
String statementName = "stmt_" + statementId + "_insert";
resultEventType =
eventAdapterService.addNestableMapType(
statementName, selPropertyTypes, null, false, false, false, false, true);
}
} else {
EventType existingType =
eventAdapterService.getExistsTypeByName(insertIntoDesc.getEventTypeName());
if (existingType == null) {
// The type may however be an auto-import or fully-qualified class name
Class clazz = null;
try {
clazz = this.methodResolutionService.resolveClass(insertIntoDesc.getEventTypeName());
} catch (EngineImportException e) {
log.debug(
"Target stream name '"
+ insertIntoDesc.getEventTypeName()
+ "' is not resolved as a class name");
}
if (clazz != null) {
existingType =
eventAdapterService.addBeanType(clazz.getName(), clazz, false, false, false);
}
}
SelectExprProcessor selectExprInsertEventBean = null;
if (existingType != null) {
selectExprInsertEventBean =
SelectExprInsertEventBeanFactory.getInsertUnderlyingNonJoin(
eventAdapterService,
existingType,
isUsingWildcard,
typeService,
exprEvaluators,
columnNames,
expressionReturnTypes,
methodResolutionService.getEngineImportService(),
insertIntoDesc,
columnNamesAsProvided);
}
if (selectExprInsertEventBean != null) {
return selectExprInsertEventBean;
} else {
boolean useMap =
EventRepresentationUtil.isMap(
annotations, configuration, CreateSchemaDesc.AssignedType.NONE);
if (useMap) {
resultEventType =
eventAdapterService.addNestableMapType(
insertIntoDesc.getEventTypeName(),
selPropertyTypes,
null,
false,
false,
false,
false,
true);
} else {
resultEventType =
eventAdapterService.addNestableObjectArrayType(
insertIntoDesc.getEventTypeName(),
selPropertyTypes,
null,
false,
false,
false,
false,
true);
}
}
}
}
if (vaeProcessor != null) {
vaeProcessor.validateEventType(resultEventType);
vaeInnerEventType = resultEventType;
resultEventType = vaeProcessor.getValueAddEventType();
isRevisionEvent = true;
}
if (!isRevisionEvent) {
if (resultEventType instanceof MapEventType) {
return new EvalInsertNoWildcardMap(selectExprContext, resultEventType);
} else {
return new EvalInsertNoWildcardObjectArray(selectExprContext, resultEventType);
}
} else {
return new EvalInsertNoWildcardRevision(
selectExprContext, resultEventType, vaeProcessor, vaeInnerEventType);
}
} catch (EventAdapterException ex) {
log.debug("Exception provided by event adapter: " + ex.getMessage(), ex);
throw new ExprValidationException(ex.getMessage(), ex);
}
}
public EPServicesContext createServicesContext(
EPServiceProvider epServiceProvider, ConfigurationInformation configSnapshot) {
// JNDI context for binding resources
EngineEnvContext jndiContext = new EngineEnvContext();
EventTypeIdGenerator eventTypeIdGenerator;
if (configSnapshot.getEngineDefaults().getAlternativeContext() == null
|| configSnapshot
.getEngineDefaults()
.getAlternativeContext()
.getEventTypeIdGeneratorFactory()
== null) {
eventTypeIdGenerator = new EventTypeIdGeneratorImpl();
} else {
EventTypeIdGeneratorFactory eventTypeIdGeneratorFactory =
(EventTypeIdGeneratorFactory)
JavaClassHelper.instantiate(
EventTypeIdGeneratorFactory.class,
configSnapshot
.getEngineDefaults()
.getAlternativeContext()
.getEventTypeIdGeneratorFactory());
eventTypeIdGenerator =
eventTypeIdGeneratorFactory.create(
new EventTypeIdGeneratorContext(epServiceProvider.getURI()));
}
// Make services that depend on snapshot config entries
EventAdapterServiceImpl eventAdapterService =
new EventAdapterServiceImpl(
eventTypeIdGenerator,
configSnapshot.getEngineDefaults().getEventMeta().getAnonymousCacheSize());
init(eventAdapterService, configSnapshot);
// New read-write lock for concurrent event processing
ManagedReadWriteLock eventProcessingRWLock = new ManagedReadWriteLock("EventProcLock", false);
TimeSourceService timeSourceService = makeTimeSource(configSnapshot);
SchedulingServiceSPI schedulingService =
SchedulingServiceProvider.newService(timeSourceService);
SchedulingMgmtService schedulingMgmtService = new SchedulingMgmtServiceImpl();
EngineImportService engineImportService = makeEngineImportService(configSnapshot);
EngineSettingsService engineSettingsService =
new EngineSettingsService(
configSnapshot.getEngineDefaults(), configSnapshot.getPlugInEventTypeResolutionURIs());
DatabaseConfigService databaseConfigService =
makeDatabaseRefService(configSnapshot, schedulingService, schedulingMgmtService);
PluggableObjectCollection plugInViews = new PluggableObjectCollection();
plugInViews.addViews(
configSnapshot.getPlugInViews(), configSnapshot.getPlugInVirtualDataWindows());
PluggableObjectCollection plugInPatternObj = new PluggableObjectCollection();
plugInPatternObj.addPatternObjects(configSnapshot.getPlugInPatternObjects());
// exception handling
ExceptionHandlingService exceptionHandlingService =
initExceptionHandling(
epServiceProvider.getURI(),
configSnapshot.getEngineDefaults().getExceptionHandling(),
configSnapshot.getEngineDefaults().getConditionHandling());
// Statement context factory
Class systemVirtualDWViewFactory = null;
if (configSnapshot.getEngineDefaults().getAlternativeContext().getVirtualDataWindowViewFactory()
!= null) {
try {
systemVirtualDWViewFactory =
Class.forName(
configSnapshot
.getEngineDefaults()
.getAlternativeContext()
.getVirtualDataWindowViewFactory());
if (!JavaClassHelper.isImplementsInterface(
systemVirtualDWViewFactory, VirtualDataWindowFactory.class)) {
throw new ConfigurationException(
"Class "
+ systemVirtualDWViewFactory.getName()
+ " does not implement the interface "
+ VirtualDataWindowFactory.class.getName());
}
} catch (ClassNotFoundException e) {
throw new ConfigurationException("Failed to look up class " + systemVirtualDWViewFactory);
}
}
StatementContextFactory statementContextFactory =
new StatementContextFactoryDefault(
plugInViews, plugInPatternObj, systemVirtualDWViewFactory);
long msecTimerResolution =
configSnapshot.getEngineDefaults().getThreading().getInternalTimerMsecResolution();
if (msecTimerResolution <= 0) {
throw new ConfigurationException(
"Timer resolution configuration not set to a valid value, expecting a non-zero value");
}
TimerService timerService =
new TimerServiceImpl(epServiceProvider.getURI(), msecTimerResolution);
VariableService variableService =
new VariableServiceImpl(
configSnapshot.getEngineDefaults().getVariables().getMsecVersionRelease(),
schedulingService,
eventAdapterService,
null);
initVariables(variableService, configSnapshot.getVariables(), engineImportService);
TableService tableService = new TableServiceImpl();
StatementLockFactory statementLockFactory =
new StatementLockFactoryImpl(
configSnapshot.getEngineDefaults().getExecution().isFairlock(),
configSnapshot.getEngineDefaults().getExecution().isDisableLocking());
StreamFactoryService streamFactoryService =
StreamFactoryServiceProvider.newService(
epServiceProvider.getURI(),
configSnapshot.getEngineDefaults().getViewResources().isShareViews());
FilterServiceSPI filterService =
FilterServiceProvider.newService(
configSnapshot.getEngineDefaults().getExecution().getFilterServiceProfile(),
configSnapshot.getEngineDefaults().getExecution().isAllowIsolatedService());
MetricReportingServiceImpl metricsReporting =
new MetricReportingServiceImpl(
configSnapshot.getEngineDefaults().getMetricsReporting(), epServiceProvider.getURI());
NamedWindowService namedWindowService =
new NamedWindowServiceImpl(
schedulingService,
variableService,
tableService,
engineSettingsService.getEngineSettings().getExecution().isPrioritized(),
eventProcessingRWLock,
exceptionHandlingService,
configSnapshot.getEngineDefaults().getLogging().isEnableQueryPlan(),
metricsReporting);
ValueAddEventService valueAddEventService = new ValueAddEventServiceImpl();
valueAddEventService.init(
configSnapshot.getRevisionEventTypes(),
configSnapshot.getVariantStreams(),
eventAdapterService,
eventTypeIdGenerator);
StatementEventTypeRef statementEventTypeRef = new StatementEventTypeRefImpl();
StatementVariableRef statementVariableRef =
new StatementVariableRefImpl(variableService, tableService);
ThreadingService threadingService =
new ThreadingServiceImpl(configSnapshot.getEngineDefaults().getThreading());
InternalEventRouterImpl internalEventRouterImpl = new InternalEventRouterImpl();
StatementIsolationServiceImpl statementIsolationService = new StatementIsolationServiceImpl();
DeploymentStateService deploymentStateService = new DeploymentStateServiceImpl();
StatementMetadataFactory stmtMetadataFactory;
if (configSnapshot.getEngineDefaults().getAlternativeContext().getStatementMetadataFactory()
== null) {
stmtMetadataFactory = new StatementMetadataFactoryDefault();
} else {
stmtMetadataFactory =
(StatementMetadataFactory)
JavaClassHelper.instantiate(
StatementMetadataFactory.class,
configSnapshot
.getEngineDefaults()
.getAlternativeContext()
.getStatementMetadataFactory());
}
ContextManagementService contextManagementService = new ContextManagementServiceImpl();
SchedulableAgentInstanceDirectory schedulableAgentInstanceDirectory =
null; // not required for Non-HA.
PatternSubexpressionPoolEngineSvc patternSubexpressionPoolSvc = null;
if (configSnapshot.getEngineDefaults().getPatterns().getMaxSubexpressions() != null) {
patternSubexpressionPoolSvc =
new PatternSubexpressionPoolEngineSvc(
configSnapshot.getEngineDefaults().getPatterns().getMaxSubexpressions(),
configSnapshot.getEngineDefaults().getPatterns().isMaxSubexpressionPreventStart());
}
MatchRecognizeStatePoolEngineSvc matchRecognizeStatePoolEngineSvc = null;
if (configSnapshot.getEngineDefaults().getMatchRecognize().getMaxStates() != null) {
matchRecognizeStatePoolEngineSvc =
new MatchRecognizeStatePoolEngineSvc(
configSnapshot.getEngineDefaults().getMatchRecognize().getMaxStates(),
configSnapshot.getEngineDefaults().getMatchRecognize().isMaxStatesPreventStart());
}
// New services context
EPServicesContext services =
new EPServicesContext(
epServiceProvider.getURI(),
schedulingService,
eventAdapterService,
engineImportService,
engineSettingsService,
databaseConfigService,
plugInViews,
statementLockFactory,
eventProcessingRWLock,
null,
jndiContext,
statementContextFactory,
plugInPatternObj,
timerService,
filterService,
streamFactoryService,
namedWindowService,
variableService,
tableService,
timeSourceService,
valueAddEventService,
metricsReporting,
statementEventTypeRef,
statementVariableRef,
configSnapshot,
threadingService,
internalEventRouterImpl,
statementIsolationService,
schedulingMgmtService,
deploymentStateService,
exceptionHandlingService,
new PatternNodeFactoryImpl(),
eventTypeIdGenerator,
stmtMetadataFactory,
contextManagementService,
schedulableAgentInstanceDirectory,
patternSubexpressionPoolSvc,
matchRecognizeStatePoolEngineSvc,
new DataFlowServiceImpl(epServiceProvider, new DataFlowConfigurationStateServiceImpl()),
new ExprDeclaredServiceImpl(),
new ContextControllerFactoryFactorySvcImpl(),
new ContextManagerFactoryServiceImpl(),
new EPStatementFactoryDefault(),
new RegexHandlerFactoryDefault(),
new ViewableActivatorFactoryDefault() {});
// Engine services subset available to statements
statementContextFactory.setStmtEngineServices(services);
// Circular dependency
StatementLifecycleSvc statementLifecycleSvc =
new StatementLifecycleSvcImpl(epServiceProvider, services);
services.setStatementLifecycleSvc(statementLifecycleSvc);
// Observers to statement events
statementLifecycleSvc.addObserver(metricsReporting);
// Circular dependency
statementIsolationService.setEpServicesContext(services);
return services;
}
/**
* Initialize event adapter service for config snapshot.
*
* @param eventAdapterService is events adapter
* @param configSnapshot is the config snapshot
*/
protected static void init(
EventAdapterService eventAdapterService, ConfigurationInformation configSnapshot) {
// Extract legacy event type definitions for each event type name, if supplied.
//
// We supply this information as setup information to the event adapter service
// to allow discovery of superclasses and interfaces during event type construction for bean
// events,
// such that superclasses and interfaces can use the legacy type definitions.
Map<String, ConfigurationEventTypeLegacy> classLegacyInfo =
new HashMap<String, ConfigurationEventTypeLegacy>();
for (Map.Entry<String, String> entry : configSnapshot.getEventTypeNames().entrySet()) {
String typeName = entry.getKey();
String className = entry.getValue();
ConfigurationEventTypeLegacy legacyDef = configSnapshot.getEventTypesLegacy().get(typeName);
if (legacyDef != null) {
classLegacyInfo.put(className, legacyDef);
}
}
eventAdapterService.setClassLegacyConfigs(classLegacyInfo);
eventAdapterService.setDefaultPropertyResolutionStyle(
configSnapshot.getEngineDefaults().getEventMeta().getClassPropertyResolutionStyle());
eventAdapterService.setDefaultAccessorStyle(
configSnapshot.getEngineDefaults().getEventMeta().getDefaultAccessorStyle());
for (String javaPackage : configSnapshot.getEventTypeAutoNamePackages()) {
eventAdapterService.addAutoNamePackage(javaPackage);
}
// Add from the configuration the Java event class names
Map<String, String> javaClassNames = configSnapshot.getEventTypeNames();
for (Map.Entry<String, String> entry : javaClassNames.entrySet()) {
// Add Java class
try {
String typeName = entry.getKey();
eventAdapterService.addBeanType(typeName, entry.getValue(), false, true, true, true);
} catch (EventAdapterException ex) {
throw new ConfigurationException("Error configuring engine: " + ex.getMessage(), ex);
}
}
// Add from the configuration the XML DOM names and type def
Map<String, ConfigurationEventTypeXMLDOM> xmlDOMNames = configSnapshot.getEventTypesXMLDOM();
for (Map.Entry<String, ConfigurationEventTypeXMLDOM> entry : xmlDOMNames.entrySet()) {
SchemaModel schemaModel = null;
if ((entry.getValue().getSchemaResource() != null)
|| (entry.getValue().getSchemaText() != null)) {
try {
schemaModel =
XSDSchemaMapper.loadAndMap(
entry.getValue().getSchemaResource(), entry.getValue().getSchemaText(), 2);
} catch (Exception ex) {
throw new ConfigurationException(ex.getMessage(), ex);
}
}
// Add XML DOM type
try {
eventAdapterService.addXMLDOMType(entry.getKey(), entry.getValue(), schemaModel, true);
} catch (EventAdapterException ex) {
throw new ConfigurationException("Error configuring engine: " + ex.getMessage(), ex);
}
}
// Add maps in dependency order such that supertypes are added before subtypes
Set<String> dependentMapOrder;
try {
Map<String, Set<String>> typesReferences =
toTypesReferences(configSnapshot.getMapTypeConfigurations());
dependentMapOrder = GraphUtil.getTopDownOrder(typesReferences);
} catch (GraphCircularDependencyException e) {
throw new ConfigurationException(
"Error configuring engine, dependency graph between map type names is circular: "
+ e.getMessage(),
e);
}
Map<String, Properties> mapNames = configSnapshot.getEventTypesMapEvents();
Map<String, Map<String, Object>> nestableMapNames =
configSnapshot.getEventTypesNestableMapEvents();
dependentMapOrder.addAll(mapNames.keySet());
dependentMapOrder.addAll(nestableMapNames.keySet());
try {
for (String mapName : dependentMapOrder) {
ConfigurationEventTypeMap mapConfig =
configSnapshot.getMapTypeConfigurations().get(mapName);
Properties propertiesUnnested = mapNames.get(mapName);
if (propertiesUnnested != null) {
Map<String, Object> propertyTypes = createPropertyTypes(propertiesUnnested);
Map<String, Object> propertyTypesCompiled =
EventTypeUtility.compileMapTypeProperties(propertyTypes, eventAdapterService);
eventAdapterService.addNestableMapType(
mapName, propertyTypesCompiled, mapConfig, true, true, true, false, false);
}
Map<String, Object> propertiesNestable = nestableMapNames.get(mapName);
if (propertiesNestable != null) {
Map<String, Object> propertiesNestableCompiled =
EventTypeUtility.compileMapTypeProperties(propertiesNestable, eventAdapterService);
eventAdapterService.addNestableMapType(
mapName, propertiesNestableCompiled, mapConfig, true, true, true, false, false);
}
}
} catch (EventAdapterException ex) {
throw new ConfigurationException("Error configuring engine: " + ex.getMessage(), ex);
}
// Add object-array in dependency order such that supertypes are added before subtypes
Set<String> dependentObjectArrayOrder;
try {
Map<String, Set<String>> typesReferences =
toTypesReferences(configSnapshot.getObjectArrayTypeConfigurations());
dependentObjectArrayOrder = GraphUtil.getTopDownOrder(typesReferences);
} catch (GraphCircularDependencyException e) {
throw new ConfigurationException(
"Error configuring engine, dependency graph between object array type names is circular: "
+ e.getMessage(),
e);
}
Map<String, Map<String, Object>> nestableObjectArrayNames =
configSnapshot.getEventTypesNestableObjectArrayEvents();
dependentObjectArrayOrder.addAll(nestableObjectArrayNames.keySet());
try {
for (String objectArrayName : dependentObjectArrayOrder) {
ConfigurationEventTypeObjectArray objectArrayConfig =
configSnapshot.getObjectArrayTypeConfigurations().get(objectArrayName);
Map<String, Object> propertyTypes = nestableObjectArrayNames.get(objectArrayName);
propertyTypes = resolveClassesForStringPropertyTypes(propertyTypes);
Map<String, Object> propertyTypesCompiled =
EventTypeUtility.compileMapTypeProperties(propertyTypes, eventAdapterService);
eventAdapterService.addNestableObjectArrayType(
objectArrayName,
propertyTypesCompiled,
objectArrayConfig,
true,
true,
true,
false,
false,
false,
null);
}
} catch (EventAdapterException ex) {
throw new ConfigurationException("Error configuring engine: " + ex.getMessage(), ex);
}
// Add plug-in event representations
Map<URI, ConfigurationPlugInEventRepresentation> plugInReps =
configSnapshot.getPlugInEventRepresentation();
for (Map.Entry<URI, ConfigurationPlugInEventRepresentation> entry : plugInReps.entrySet()) {
String className = entry.getValue().getEventRepresentationClassName();
Class eventRepClass;
try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
eventRepClass = Class.forName(className, true, cl);
} catch (ClassNotFoundException ex) {
throw new ConfigurationException(
"Failed to load plug-in event representation class '" + className + "'", ex);
}
Object pluginEventRepObj;
try {
pluginEventRepObj = eventRepClass.newInstance();
} catch (InstantiationException ex) {
throw new ConfigurationException(
"Failed to instantiate plug-in event representation class '"
+ className
+ "' via default constructor",
ex);
} catch (IllegalAccessException ex) {
throw new ConfigurationException(
"Illegal access to instantiate plug-in event representation class '"
+ className
+ "' via default constructor",
ex);
}
if (!(pluginEventRepObj instanceof PlugInEventRepresentation)) {
throw new ConfigurationException(
"Plug-in event representation class '"
+ className
+ "' does not implement the required interface "
+ PlugInEventRepresentation.class.getName());
}
URI eventRepURI = entry.getKey();
PlugInEventRepresentation pluginEventRep = (PlugInEventRepresentation) pluginEventRepObj;
Serializable initializer = entry.getValue().getInitializer();
PlugInEventRepresentationContext context =
new PlugInEventRepresentationContext(eventAdapterService, eventRepURI, initializer);
try {
pluginEventRep.init(context);
eventAdapterService.addEventRepresentation(eventRepURI, pluginEventRep);
} catch (Throwable t) {
throw new ConfigurationException(
"Plug-in event representation class '"
+ className
+ "' and URI '"
+ eventRepURI
+ "' did not initialize correctly : "
+ t.getMessage(),
t);
}
}
// Add plug-in event type names
Map<String, ConfigurationPlugInEventType> plugInNames = configSnapshot.getPlugInEventTypes();
for (Map.Entry<String, ConfigurationPlugInEventType> entry : plugInNames.entrySet()) {
String name = entry.getKey();
ConfigurationPlugInEventType config = entry.getValue();
eventAdapterService.addPlugInEventType(
name, config.getEventRepresentationResolutionURIs(), config.getInitializer());
}
}
public void addVariable(String variableName, Class type, Object initializationValue)
throws ConfigurationException {
addVariable(variableName, type.getName(), initializationValue, false);
}
public void addImport(Class importClass) {
addImport(importClass.getName());
}