private static ExprEvaluator[] GetEvaluators(IList <ExprNode> parameters)
{
var inputExpr = new ExprEvaluator[parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{
ExprNode innerExpr = parameters[i];
ExprEvaluator inner = innerExpr.ExprEvaluator;
// Time periods get special attention
if (innerExpr is ExprTimePeriod)
{
var timePeriod = (ExprTimePeriod)innerExpr;
inputExpr[i] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => timePeriod.EvaluateGetTimePeriod(evaluateParams),
ReturnType = typeof(TimePeriod),
};
}
else
{
inputExpr[i] = inner;
}
}
return(inputExpr);
}
public static ExprEvaluator GetDefaultEvaluator(ExprNode[] childNodes, bool join, EventType[] typesPerStream)
{
ExprEvaluator evaluator;
if (childNodes.Length > 1)
{
evaluator = GetMultiNodeEvaluator(childNodes, join, typesPerStream);
}
else if (childNodes.Length > 0)
{
if (childNodes[0] is ExprWildcard)
{
evaluator = GetWildcardEvaluator(typesPerStream, join);
}
else
{
// Use the evaluation node under the aggregation node to obtain the aggregation value
evaluator = childNodes[0].ExprEvaluator;
}
}
// For aggregation that doesn't evaluate any particular sub-expression, return null on evaluation
else
{
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => null,
ProcReturnType = () => null,
};
}
return(evaluator);
}
public static StatViewAdditionalProps Make(ExprNode[] validated, int startIndex, EventType parentEventType)
{
if (validated.Length <= startIndex)
{
return(null);
}
IList <String> additionalProps = new List <String>();
IList <ExprEvaluator> lastValueExpr = new List <ExprEvaluator>();
var copyAllProperties = false;
for (var i = startIndex; i < validated.Length; i++)
{
if (validated[i] is ExprWildcard)
{
copyAllProperties = true;
}
additionalProps.Add(ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated[i]));
lastValueExpr.Add(validated[i].ExprEvaluator);
}
if (copyAllProperties)
{
foreach (var propertyDescriptor in parentEventType.PropertyDescriptors)
{
if (propertyDescriptor.IsFragment)
{
continue;
}
additionalProps.Add(propertyDescriptor.PropertyName);
var getter = parentEventType.GetGetter(propertyDescriptor.PropertyName);
var type = propertyDescriptor.PropertyType;
ExprEvaluator exprEvaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => getter.Get(evaluateParams.EventsPerStream[0]),
ReturnType = type
};
lastValueExpr.Add(exprEvaluator);
}
}
var addPropsArr = additionalProps.ToArray();
var valueExprArr = lastValueExpr.ToArray();
return(new StatViewAdditionalProps(addPropsArr, valueExprArr));
}
private static SelectExprProcessor InitializeJoinWildcardInternal(
EventType eventType,
ICollection <WriteablePropertyDescriptor> writables,
string[] streamNames,
EventType[] streamTypes,
EngineImportService engineImportService,
EventAdapterService eventAdapterService,
string statementName,
string engineURI)
{
var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType);
var writablePropertiesList = new List <WriteablePropertyDescriptor>();
var evaluatorsList = new List <ExprEvaluator>();
var widenersList = new List <TypeWidener>();
// loop over all columns selected, if any
for (var i = 0; i < streamNames.Length; i++)
{
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
foreach (var desc in writables)
{
if (!desc.PropertyName.Equals(streamNames[i]))
{
continue;
}
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
streamNames[i], streamTypes[i].UnderlyingType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, engineURI);
selectedWritable = desc;
break;
}
if (selectedWritable == null)
{
var message = "Stream underlying object for stream '" + streamNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property or setter method?)";
throw new ExprValidationException(message);
}
var streamNum = i;
var returnType = streamTypes[streamNum].UnderlyingType;
var evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[streamNum];
if (theEvent != null)
{
return(theEvent.Underlying);
}
return(null);
},
ProcReturnType = () => returnType
};
// add
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprEvaluators = evaluatorsList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturer eventManufacturer;
try
{
eventManufacturer = eventAdapterService.GetManufacturer(
eventType, writableProperties, engineImportService, false);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(e.Message, e);
}
return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners));
}
private static SelectExprProcessor InitializeSetterManufactor(
EventType eventType,
ICollection <WriteablePropertyDescriptor> writables,
bool isUsingWildcard,
StreamTypeService typeService,
ExprEvaluator[] expressionNodes,
string[] columnNames,
Object[] expressionReturnTypes,
EngineImportService engineImportService,
EventAdapterService eventAdapterService,
string statementName)
{
var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType);
var writablePropertiesList = new List <WriteablePropertyDescriptor>();
var evaluatorsList = new List <ExprEvaluator>();
var widenersList = new List <TypeWidener>();
// loop over all columns selected, if any
for (var i = 0; i < columnNames.Length; i++)
{
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
var evaluator = expressionNodes[i];
foreach (var desc in writables)
{
if (!desc.PropertyName.Equals(columnNames[i]))
{
continue;
}
var columnType = expressionReturnTypes[i];
if (columnType == null)
{
TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], null, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer,
statementName, typeService.EngineURIQualifier);
}
else if (columnType is EventType)
{
var columnEventType = (EventType)columnType;
var returnType = columnEventType.UnderlyingType;
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], columnEventType.UnderlyingType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, typeService.EngineURIQualifier);
// handle evaluator returning an event
if (TypeHelper.IsSubclassOrImplementsInterface(returnType, desc.PropertyType))
{
selectedWritable = desc;
widener = input =>
{
var eventBean = input as EventBean;
if (eventBean != null)
{
return(eventBean.Underlying);
}
return(input);
};
continue;
}
// find stream
var streamNum = 0;
for (var j = 0; j < typeService.EventTypes.Length; j++)
{
if (Equals(typeService.EventTypes[j], columnEventType))
{
streamNum = j;
break;
}
}
var streamNumEval = streamNum;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[streamNumEval];
if (theEvent != null)
{
return(theEvent.Underlying);
}
return(null);
},
ProcReturnType = () => returnType
};
}
else if (columnType is EventType[])
{
// handle case where the select-clause contains an fragment array
var columnEventType = ((EventType[])columnType)[0];
var componentReturnType = columnEventType.UnderlyingType;
var arrayReturnType = Array.CreateInstance(componentReturnType, 0).GetType();
var allowObjectArrayToCollectionConversion = eventType is AvroSchemaEventType;
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], arrayReturnType, desc.PropertyType, desc.PropertyName,
allowObjectArrayToCollectionConversion, typeWidenerCustomizer, statementName,
typeService.EngineURIQualifier);
var inner = evaluator;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var result = inner.Evaluate(evaluateParams);
if (!(result is EventBean[]))
{
return(null);
}
var events = (EventBean[])result;
var values = Array.CreateInstance(componentReturnType, events.Length);
for (var ii = 0; ii < events.Length; ii++)
{
values.SetValue(events[ii].Underlying, ii);
}
return(values);
},
ProcReturnType = () => componentReturnType
};
}
else if (!(columnType is Type))
{
var message = "Invalid assignment of column '" + columnNames[i] +
"' of type '" + columnType +
"' to event property '" + desc.PropertyName +
"' typed as '" + desc.PropertyType.FullName +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
else
{
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], (Type)columnType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, typeService.EngineURIQualifier);
}
selectedWritable = desc;
break;
}
if (selectedWritable == null)
{
var message = "Column '" + columnNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
// add
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
// handle wildcard
if (isUsingWildcard)
{
var sourceType = typeService.EventTypes[0];
foreach (var eventPropDescriptor in sourceType.PropertyDescriptors)
{
if (eventPropDescriptor.RequiresIndex || (eventPropDescriptor.RequiresMapKey))
{
continue;
}
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
ExprEvaluator evaluator = null;
foreach (var writableDesc in writables)
{
if (!writableDesc.PropertyName.Equals(eventPropDescriptor.PropertyName))
{
continue;
}
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
eventPropDescriptor.PropertyName, eventPropDescriptor.PropertyType, writableDesc.PropertyType,
writableDesc.PropertyName, false, typeWidenerCustomizer, statementName,
typeService.EngineURIQualifier);
selectedWritable = writableDesc;
var propertyName = eventPropDescriptor.PropertyName;
var propertyType = eventPropDescriptor.PropertyType;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[0];
if (theEvent != null)
{
return(theEvent.Get(propertyName));
}
return(null);
},
ProcReturnType = () => propertyType
};
break;
}
if (selectedWritable == null)
{
var message = "Event property '" + eventPropDescriptor.PropertyName +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprEvaluators = evaluatorsList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturer eventManufacturer;
try
{
eventManufacturer = eventAdapterService.GetManufacturer(
eventType, writableProperties, engineImportService, false);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(e.Message, e);
}
return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
_initialDelayMSec = (long)(initialDelay * 1000);
_periodDelayMSec = (long)(interval * 1000);
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException(
"BeaconSource operator requires one output stream but produces " + context.OutputPorts.Count +
" streams");
}
// Check if a type is declared
var port = context.OutputPorts[0];
ICollection <string> props;
if (port.OptionalDeclaredType != null && port.OptionalDeclaredType.EventType != null)
{
var outputEventType = port.OptionalDeclaredType.EventType;
_produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var writables = SetupProperties(props.ToArray(), outputEventType, context.StatementContext);
_manufacturer = context.ServicesContext.EventAdapterService.GetManufacturer(
outputEventType, writables, context.ServicesContext.EngineImportService, false);
var index = 0;
_evaluators = new ExprEvaluator[writables.Length];
TypeWidenerCustomizer typeWidenerCustomizer =
context.ServicesContext.EventAdapterService.GetTypeWidenerCustomizer(outputEventType);
foreach (var writeable in writables)
{
var providedProperty = _allProperties.Get(writeable.PropertyName);
if (providedProperty is ExprNode)
{
var exprNode = (ExprNode)providedProperty;
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var exprEvaluator = validated.ExprEvaluator;
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated), exprEvaluator.ReturnType,
writeable.PropertyType, writeable.PropertyName, false, typeWidenerCustomizer,
context.StatementContext.StatementName, context.Engine.URI);
if (widener != null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var value = exprEvaluator.Evaluate(evaluateParams);
return(widener.Invoke(value));
},
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = exprEvaluator;
}
}
else if (providedProperty == null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => null,
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => providedProperty,
ProcReturnType = () => providedProperty.GetType()
};
}
index++;
}
return(null); // no changing types
}
// No type has been declared, we can create one
var anonymousTypeName = context.DataflowName + "-beacon";
var types = new LinkedHashMap <string, Object>();
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var count = 0;
_evaluators = new ExprEvaluator[props.Count];
foreach (var propertyName in props)
{
var exprNode = (ExprNode)_allProperties.Get(propertyName);
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var evaluateParamsX = new EvaluateParams(null, true, context.AgentInstanceContext);
var value = validated.ExprEvaluator.Evaluate(evaluateParamsX);
if (value == null)
{
types.Put(propertyName, null);
}
else
{
types.Put(propertyName, value.GetType());
}
_evaluators[count] = new ProxyExprEvaluator()
{
ProcEvaluate = (evaluateParams) => value,
ProcReturnType = () => null
};
count++;
}
EventType type =
context.ServicesContext.EventAdapterService.CreateAnonymousObjectArrayType(anonymousTypeName, types);
return(new DataFlowOpInitializeResult(
new GraphTypeDesc[]
{
new GraphTypeDesc(false, true, type)
}));
}
public static Pair <FastConstructor, ExprEvaluator[]> GetManufacturer(Type targetClass, EngineImportService engineImportService, ExprEvaluator[] exprEvaluators, object[] expressionReturnTypes)
{
var ctorTypes = new Type[expressionReturnTypes.Length];
var evaluators = new ExprEvaluator[exprEvaluators.Length];
for (var i = 0; i < expressionReturnTypes.Length; i++)
{
var columnType = expressionReturnTypes[i];
if (columnType is Type || columnType == null)
{
ctorTypes[i] = (Type)expressionReturnTypes[i];
evaluators[i] = exprEvaluators[i];
continue;
}
if (columnType is EventType)
{
var columnEventType = (EventType)columnType;
var returnType = columnEventType.UnderlyingType;
var inner = exprEvaluators[i];
evaluators[i] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var theEvent = (EventBean)inner.Evaluate(evaluateParams);
if (theEvent != null)
{
return(theEvent.Underlying);
}
return(null);
},
ProcReturnType = () =>
{
return(returnType);
},
};
ctorTypes[i] = returnType;
continue;
}
// handle case where the select-clause contains an fragment array
if (columnType is EventType[])
{
var columnEventType = ((EventType[])columnType)[0];
var componentReturnType = columnEventType.UnderlyingType;
var inner = exprEvaluators[i];
evaluators[i] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var result = inner.Evaluate(evaluateParams);
if (!(result is EventBean[]))
{
return(null);
}
var events = (EventBean[])result;
var values = Array.CreateInstance(componentReturnType, events.Length);
for (var jj = 0; jj < events.Length; jj++)
{
values.SetValue(events[jj].Underlying, jj);
}
return(values);
},
ProcReturnType = () =>
{
return(componentReturnType);
},
};
continue;
}
var message = "Invalid assignment of expression " + i + " returning type '" + columnType +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
FastConstructor fctor;
try
{
var ctor = engineImportService.ResolveCtor(targetClass, ctorTypes);
var fastClass = FastClass.Create(targetClass);
return(new Pair <FastConstructor, ExprEvaluator[]>(fastClass.GetConstructor(ctor), evaluators));
}
catch (EngineImportException ex)
{
throw new ExprValidationException("Failed to find a suitable constructor for type '" + targetClass.Name + "': " + ex.Message, ex);
}
}
/// <summary>
/// Produces an aggregation service for use with match-recognice.
/// </summary>
/// <param name="numStreams">number of streams</param>
/// <param name="measureExprNodesPerStream">measure nodes</param>
/// <param name="typesPerStream">The types per stream.</param>
/// <returns>
/// service
/// </returns>
public static AggregationServiceMatchRecognizeFactoryDesc GetServiceMatchRecognize(
int numStreams,
IDictionary <int, IList <ExprAggregateNode> > measureExprNodesPerStream,
EventType[] typesPerStream)
{
var equivalencyListPerStream = new SortedDictionary <int, IList <AggregationServiceAggExpressionDesc> >();
foreach (var entry in measureExprNodesPerStream)
{
IList <AggregationServiceAggExpressionDesc> equivalencyList = new List <AggregationServiceAggExpressionDesc>();
equivalencyListPerStream.Put(entry.Key, equivalencyList);
foreach (var selectAggNode in entry.Value)
{
AddEquivalent(selectAggNode, equivalencyList);
}
}
var aggregatorsPerStream = new LinkedHashMap <int, AggregationMethodFactory[]>();
var evaluatorsPerStream = new Dictionary <int, ExprEvaluator[]>();
foreach (var equivalencyPerStream in equivalencyListPerStream)
{
var index = 0;
int stream = equivalencyPerStream.Key;
var aggregators = new AggregationMethodFactory[equivalencyPerStream.Value.Count];
aggregatorsPerStream.Put(stream, aggregators);
var evaluators = new ExprEvaluator[equivalencyPerStream.Value.Count];
evaluatorsPerStream.Put(stream, evaluators);
foreach (var aggregation in equivalencyPerStream.Value)
{
var aggregateNode = aggregation.AggregationNode;
if (aggregateNode.ChildNodes.Length > 1)
{
evaluators[index] = ExprMethodAggUtil.GetMultiNodeEvaluator(aggregateNode.ChildNodes, typesPerStream.Length > 1, typesPerStream);
}
else if (aggregateNode.ChildNodes.Length > 0)
{
// Use the evaluation node under the aggregation node to obtain the aggregation value
evaluators[index] = aggregateNode.ChildNodes[0].ExprEvaluator;
}
// For aggregation that doesn't evaluate any particular sub-expression, return null on evaluation
else
{
evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = args => null,
ProcReturnType = () => null
};
}
aggregators[index] = aggregateNode.Factory;
index++;
}
}
// Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation.
var columnNumber = 0;
IList <AggregationServiceAggExpressionDesc> allExpressions = new List <AggregationServiceAggExpressionDesc>();
foreach (var equivalencyPerStream in equivalencyListPerStream)
{
foreach (var entry in equivalencyPerStream.Value)
{
entry.ColumnNum = columnNumber++;
}
allExpressions.AddAll(equivalencyPerStream.Value);
}
AggregationServiceMatchRecognizeFactory factory = new AggregationServiceMatchRecognizeFactoryImpl(numStreams, aggregatorsPerStream, evaluatorsPerStream);
return(new AggregationServiceMatchRecognizeFactoryDesc(factory, allExpressions));
}
public EvalSelectNoWildcardAvro(
SelectExprContext selectExprContext,
EventType resultEventType,
string statementName,
string engineURI)
{
_selectExprContext = selectExprContext;
_resultEventType = (AvroEventType) resultEventType;
_evaluator = new ExprEvaluator[selectExprContext.ExpressionNodes.Length];
var typeWidenerCustomizer =
selectExprContext.EventAdapterService.GetTypeWidenerCustomizer(resultEventType);
for (var i = 0; i < _evaluator.Length; i++)
{
var eval = selectExprContext.ExpressionNodes[i];
_evaluator[i] = eval;
if (eval is SelectExprProcessorEvalByGetterFragment)
{
_evaluator[i] = HandleFragment((SelectExprProcessorEvalByGetterFragment) eval);
}
else if (eval is SelectExprProcessorEvalStreamInsertUnd)
{
var und = (SelectExprProcessorEvalStreamInsertUnd) eval;
_evaluator[i] = new ProxyExprEvaluator
{
ProcEvaluate = (evaluateParams) =>
{
var @event = evaluateParams.EventsPerStream[und.StreamNum];
if (@event == null)
{
return null;
}
return @event.Underlying;
},
ProcReturnType = () => { return typeof (GenericRecord); }
};
}
else if (eval is SelectExprProcessorEvalTypableMap)
{
var typableMap = (SelectExprProcessorEvalTypableMap) eval;
_evaluator[i] = new SelectExprProcessorEvalAvroMapToAvro(
typableMap.InnerEvaluator, ((AvroEventType) resultEventType).SchemaAvro,
selectExprContext.ColumnNames[i]);
}
else if (eval is SelectExprProcessorEvalStreamInsertNamedWindow)
{
var nw = (SelectExprProcessorEvalStreamInsertNamedWindow) eval;
_evaluator[i] = new ProxyExprEvaluator
{
ProcEvaluate = (evaluateParams) =>
{
var @event = evaluateParams.EventsPerStream[nw.StreamNum];
if (@event == null)
{
return null;
}
return @event.Underlying;
},
ProcReturnType = () => { return typeof (GenericRecord); }
};
}
else if (eval.ReturnType != null && eval.ReturnType.IsArray)
{
var widener = TypeWidenerFactory.GetArrayToCollectionCoercer(eval.ReturnType.GetElementType());
//if (eval.ReturnType == typeof (byte[]))
//{
// widener = TypeWidenerFactory.BYTE_ARRAY_TO_BYTE_BUFFER_COERCER;
//}
_evaluator[i] = new SelectExprProcessorEvalAvroArrayCoercer(eval, widener);
}
else
{
var propertyName = selectExprContext.ColumnNames[i];
var propertyType = resultEventType.GetPropertyType(propertyName);
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(
propertyName, eval.ReturnType, propertyType, propertyName, true, typeWidenerCustomizer,
statementName, engineURI);
if (widener != null)
{
_evaluator[i] = new SelectExprProcessorEvalAvroArrayCoercer(eval, widener);
}
}
}
}
