public ObjectArrayBackedEventBean MakeOA(int agentInstanceId, object groupByKey, object groupKeyBinding, AggregationServicePassThru passThru)
{
var row = MakeAggs(agentInstanceId, groupByKey, groupKeyBinding, passThru);
var data = new object[_objectArrayEventType.PropertyDescriptors.Count];
data[0] = row;
if (_groupKeyIndexes.Length == 1)
{
data[_groupKeyIndexes[0]] = groupByKey;
}
else
{
if (_groupKeyIndexes.Length > 1)
{
object[] keys = ((MultiKeyUntyped)groupByKey).Keys;
for (int i = 0; i < _groupKeyIndexes.Length; i++)
{
data[_groupKeyIndexes[i]] = keys[i];
}
}
}
return((ObjectArrayBackedEventBean)_eventAdapterService.AdapterForType(data, _objectArrayEventType));
}
public Object ByteArrayToObject(byte[] bytes, EventAdapterService eventAdapterService)
{
var state = (ContextControllerInitTermState)SerializerUtil.ByteArrToObject(bytes);
foreach (var entry in state.PatternData.ToArray())
{
if (entry.Value is EventBeanNameValuePair)
{
var @event = (EventBeanNameValuePair)entry.Value;
var type = eventAdapterService.GetEventTypeByName(@event.EventTypeName);
var underlying = SerializerUtil.ByteArrToObject(@event.Bytes);
state.PatternData.Put(entry.Key, eventAdapterService.AdapterForType(underlying, type));
}
}
return(state);
}
public EventBean Convert(EventBean @event, EvaluateParams evalParams)
{
var data = ConvertToUnd(@event, evalParams);
return(_eventAdapterService.AdapterForType(data, _publicEventType));
}
private void CreateNewVariable(String variableName, String optionalContextName, Type type, EventType eventType, bool constant, Object value)
{
lock (this)
{
// check type
var variableType = type.GetBoxedType();
// check if it exists
var metaData = _variables.Get(variableName);
if (metaData != null)
{
throw new VariableExistsException(VariableServiceUtil.GetAlreadyDeclaredEx(variableName, false));
}
// find empty spot
var emptySpot = -1;
var count = 0;
foreach (var entry in _variableVersionsPerCP)
{
if (entry == null)
{
emptySpot = count;
break;
}
count++;
}
int variableNumber;
if (emptySpot != -1)
{
variableNumber = emptySpot;
_variableVersionsPerCP[emptySpot] = new ConcurrentDictionary <int, VariableReader>();
_changeCallbacksPerCP[emptySpot] = null;
}
else
{
variableNumber = _currentVariableNumber;
_variableVersionsPerCP.Add(new ConcurrentDictionary <int, VariableReader>());
_changeCallbacksPerCP.Add(null);
_currentVariableNumber++;
}
// check coercion
var coercedValue = value;
if (eventType != null)
{
if ((value != null) && (!TypeHelper.IsSubclassOrImplementsInterface(value.GetType(), eventType.UnderlyingType)))
{
throw new VariableTypeException("Variable '" + variableName
+ "' of declared event type '" + eventType.Name + "' underlying type '" + eventType.UnderlyingType.FullName +
"' cannot be assigned a value of type '" + value.GetType().FullName + "'");
}
coercedValue = _eventAdapterService.AdapterForType(value, eventType);
}
else if (variableType == typeof(object))
{
// no validation
}
else
{
// allow string assignments to non-string variables
if ((coercedValue != null) && (coercedValue is String))
{
try {
coercedValue = TypeHelper.Parse(variableType, (String)coercedValue);
}
catch (Exception ex)
{
throw new VariableTypeException(
string.Format(
"Variable '{0}' of declared type {1} cannot be initialized by value '{2}': {3}: {4}",
variableName,
variableType.GetTypeNameFullyQualPretty(),
coercedValue,
ex.GetType().FullName,
ex.Message));
}
}
if ((coercedValue != null) && (variableType.GetBoxedType() != coercedValue.GetBoxedType()))
{
// if the declared type is not numeric or the init value is not numeric, fail
if ((!variableType.IsNumeric()) || (!(coercedValue.IsNumber())))
{
throw GetVariableTypeException(variableName, variableType, coercedValue.GetType());
}
if (!(coercedValue.GetType().CanCoerce(variableType)))
{
throw GetVariableTypeException(variableName, variableType, coercedValue.GetType());
}
// coerce
coercedValue = CoercerFactory.CoerceBoxed(coercedValue, variableType);
}
}
var initialState = coercedValue;
VariableStateFactory stateFactory = new VariableStateFactoryConst(initialState);
metaData = new VariableMetaData(variableName, optionalContextName, variableNumber, variableType, eventType, constant, stateFactory);
_variables.Put(variableName, metaData);
}
}
public Object Evaluate(EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
var @event = eventsPerStream[StreamNum];
return(@event == null ? null : _eventAdapterService.AdapterForType(@event.Underlying, _namedWindowAsType));
}
public EventBean Convert(EventBean @event, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context)
{
var data = ConvertToUnd(@event, eventsPerStream, isNewData, context);
return(_eventAdapterService.AdapterForType(data, _publicEventType));
}
