public EventBean AdapterForBean( object theEvent, string eventTypeName) { var eventType = FindType(eventTypeName); return typedEventFactory.AdapterForTypedObject(theEvent, eventType); }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="result">result</param> /// <param name="eventType">type</param> /// <param name="eventBeanTypedEventFactory">event service</param> /// <returns>fragment</returns> public static object GetBNFragmentPono( object result, BeanEventType eventType, EventBeanTypedEventFactory eventBeanTypedEventFactory) { if (result == null) { return null; } if (result is EventBean[]) { return result; } if (result is EventBean) { return result; } if (result is Array array) { var len = array.Length; var events = new EventBean[len]; for (var i = 0; i < events.Length; i++) { events[i] = eventBeanTypedEventFactory .AdapterForTypedObject(array.GetValue(i), eventType); } return events; } return eventBeanTypedEventFactory.AdapterForTypedObject(result, eventType); }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// Returns the fragment for dynamic properties. /// </summary> /// <param name="object">to inspect</param> /// <param name="eventBeanTypedEventFactory">factory for event beans and event types</param> /// <param name="beanEventTypeFactory">bean factory</param> /// <returns>fragment</returns> public static object GetFragmentDynamic( object @object, EventBeanTypedEventFactory eventBeanTypedEventFactory, BeanEventTypeFactory beanEventTypeFactory) { if (@object == null) { return null; } BeanEventType fragmentEventType = null; var isArray = false; var objectType = @object.GetType(); if (objectType.IsArray) { if (objectType.GetElementType().IsFragmentableType()) { isArray = true; fragmentEventType = beanEventTypeFactory.GetCreateBeanType(objectType.GetElementType(), false); } } else { if (objectType.IsFragmentableType()) { fragmentEventType = beanEventTypeFactory.GetCreateBeanType(objectType, false); } } if (fragmentEventType == null) { return null; } if (isArray) { var objectArray = (Array) @object; var len = objectArray.Length; var events = new EventBean[len]; var countFilled = 0; for (var i = 0; i < len; i++) { var element = objectArray.GetValue(i); if (element == null) { continue; } events[countFilled] = eventBeanTypedEventFactory.AdapterForTypedObject(element, fragmentEventType); countFilled++; } if (countFilled == len) { return events; } if (countFilled == 0) { return new EventBean[0]; } var returnVal = new EventBean[countFilled]; Array.Copy(events, 0, returnVal, 0, countFilled); return returnVal; } return eventBeanTypedEventFactory.AdapterForTypedObject(@object, fragmentEventType); }
private EventBean GetEventBean(object theEvent) { // type check if (theEvent.GetType() != _beanEventType.UnderlyingType) { lock (this) { if (!_compatibleClasses.Contains(theEvent.GetType())) { if (TypeHelper.IsSubclassOrImplementsInterface( theEvent.GetType(), _beanEventType.UnderlyingType)) { _compatibleClasses.Add(theEvent.GetType()); } else { throw new EPException( "Event object of type " + theEvent.GetType().CleanName() + " does not equal, extend or implement the type " + _beanEventType.UnderlyingType.CleanName() + " of event type '" + _beanEventType.Name + "'"); } } } } return _eventBeanTypedEventFactory.AdapterForTypedObject(theEvent, _beanEventType); }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="objectArray">array</param> /// <param name="fragmentEventType">fragment type</param> /// <param name="eventBeanTypedEventFactory">event adapters</param> /// <returns>array</returns> public static object ToFragmentArray( object[] objectArray, BeanEventType fragmentEventType, EventBeanTypedEventFactory eventBeanTypedEventFactory) { var events = new EventBean[objectArray.Length]; var countFilled = 0; for (var i = 0; i < objectArray.Length; i++) { var element = objectArray[i]; if (element == null) { continue; } events[countFilled] = eventBeanTypedEventFactory.AdapterForTypedObject(element, fragmentEventType); countFilled++; } if (countFilled == objectArray.Length) { return events; } if (countFilled == 0) { return new EventBean[0]; } var returnVal = new EventBean[countFilled]; Array.Copy(events, 0, returnVal, 0, countFilled); return returnVal; }
public static object HandleJsonProvidedCreateFragmentArray( object value, EventType fragmentType, EventBeanTypedEventFactory factory) { if (value == null) { return null; } var array = value as Array; var len = array.Length; var events = new EventBean[len]; if (fragmentType is JsonEventType) { for (var i = 0; i < len; i++) { object item = array.GetValue(i); events[i] = factory.AdapterForTypedJson(item, fragmentType); } } else { for (var i = 0; i < len; i++) { object item = array.GetValue(i); events[i] = factory.AdapterForTypedObject(item, fragmentType); } } return events; }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// Returns the fragment for dynamic properties. /// </summary> /// <param name="object">to inspect</param> /// <param name="fragmentEventType">type</param> /// <param name="eventBeanTypedEventFactory">factory for event beans and event types</param> /// <returns>fragment</returns> public static object ToFragmentIterable( object @object, BeanEventType fragmentEventType, EventBeanTypedEventFactory eventBeanTypedEventFactory) { if (!(@object is IEnumerable enumerable)) { return null; } var enumerator = enumerable.GetEnumerator(); if (!enumerator.MoveNext()) { return new EventBean[0]; } var events = new ArrayDeque<EventBean>(); do { var next = enumerator.Current; if (next == null) { continue; } events.Add(eventBeanTypedEventFactory.AdapterForTypedObject(next, fragmentEventType)); } while (enumerator.MoveNext()); return events.ToArray(); }
public EventBean Copy(EventBean theEvent) { var underlying = theEvent.Underlying; object copied; try { copied = _copyMethod.Invoke(underlying, null); } catch (EPException) { throw; } catch (MemberAccessException e) { Log.Error("MemberAccessException copying event object for update: " + e.Message, e); return null; } catch (TargetException e) { Log.Error("TargetException copying event object for update: " + e.Message, e); return null; } catch (Exception e) { Log.Error("RuntimeException copying event object for update: " + e.Message, e); return null; } return _eventAdapterService.AdapterForTypedObject(copied, _beanEventType); }
public IEnumerator<EventBean> GetEnumerator() { for (int ii = 0; ii < array.Length; ii++) { yield return eventBeanTypedEventFactory.AdapterForTypedObject( array.GetValue(ii), type); } }
public EventBean Wrap(object underlying) { var bean = eventBeanTypedEventFactory.AdapterForTypedObject(underlying, beanEventType); return eventBeanTypedEventFactory.AdapterForTypedWrapper( bean, Collections.GetEmptyMap<string, object>(), wrapperEventType); }
public ICollection<EventBean> ConvertNonNull(object result) { // there is a need to read the iterator to the cache since if it's iterated twice, the iterator is already exhausted return result .UnwrapEnumerable<object>() .Select(v => eventBeanTypedEventFactory.AdapterForTypedObject(v, type)) .ToList(); //return new WrappingCollection(eventBeanTypedEventFactory, type, ((IEnumerable) result).GetEnumerator()); }
public static FlexCollection UnwrapEventBeans( EventBeanTypedEventFactory eventBeanTypedEventFactory, BeanEventType type, IEnumerable enumerable) { return FlexCollection.Of( enumerable .Cast<object>() .Select(value => eventBeanTypedEventFactory.AdapterForTypedObject(value, type)) .ToList()); }
private object GetFragmentFromObject(object value) { if (_isArray) { return ToFragmentArray((object[]) value, _fragmentEventType, _eventBeanTypedEventFactory); } else if (_isIterable) { return ToFragmentIterable(value, _fragmentEventType, _eventBeanTypedEventFactory); } else { return _eventBeanTypedEventFactory.AdapterForTypedObject(value, _fragmentEventType); } }
public static object HandleJsonProvidedCreateFragmentSimple( object underlying, FieldInfo field, EventType fragmentType, EventBeanTypedEventFactory factory) { var prop = GetJsonProvidedSimpleProp(underlying, field); if (prop == null) { return null; } if (fragmentType is JsonEventType) { return factory.AdapterForTypedJson(prop, fragmentType); } return factory.AdapterForTypedObject(prop, fragmentType); }
public EventBean Copy(EventBean theEvent) { var underlying = theEvent.Underlying; object copied; try { copied = _copier.Copy(underlying); } catch (IOException e) { Log.Error("IOException copying event object for update: " + e.Message, e); return null; } catch (TypeLoadException e) { Log.Error("Exception copying event object for update: " + e.Message, e); return null; } return _eventAdapterService.AdapterForTypedObject(copied, _beanEventType); }
private static object GetCoercedValue( object value, EventType eventType, string variableName, Type variableType, EventBeanTypedEventFactory eventBeanTypedEventFactory) { 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.CleanName() + "' cannot be assigned a value of type '" + value.GetType().CleanName() + "'"); } if (eventBeanTypedEventFactory != EventBeanTypedEventFactoryCompileTime.INSTANCE) { coercedValue = eventBeanTypedEventFactory.AdapterForTypedObject(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( "Variable '" + variableName + "' of declared type " + variableType.CleanName() + " cannot be initialized by value '" + coercedValue + "': " + ex); } } if (coercedValue != null && !TypeHelper.IsSubclassOrImplementsInterface(coercedValue.GetType(), variableType)) { var coercedValueType = coercedValue.GetType(); // Lets see if the coerced value is an array of an element, whereas the variable is an array // of the boxed variant of the type. Technically, the arrays are not compatible and we need // to coerce as a result. if (coercedValueType.IsArray && variableType.IsArray && coercedValueType.GetElementType().GetBoxedType() == variableType.GetElementType()) { var coercedSourceArray = (Array) coercedValue; var coercedDestArray = Arrays.CreateInstanceChecked(variableType.GetElementType(), coercedSourceArray.Length); for (int ii = 0; ii < coercedSourceArray.Length; ii++) { coercedDestArray.SetValue(coercedSourceArray.GetValue(ii), ii); } coercedValue = coercedDestArray; } else { // 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, coercedValueType); } // coerce coercedValue = TypeHelper.CoerceBoxed(coercedValue, variableType); } } } return coercedValue; }
public EventBean Wrap(object underlying) { return eventBeanTypedEventFactory.AdapterForTypedObject(underlying, type); }
public EventBean Make(object[] properties) { var instance = MakeUnderlying(properties); return eventBeanTypedEventFactory.AdapterForTypedObject(instance, beanEventType); }
public void CheckAndWrite( string deploymentId, string variableName, int agentInstanceId, object newValue) { var entry = DeploymentsWithVariables.Get(deploymentId); if (entry == null) { throw new ArgumentException("Failed to find variable deployment id '" + deploymentId + "'"); } var variable = entry.GetVariable(variableName); var variableNumber = variable.VariableNumber; if (newValue == null) { Write(variableNumber, agentInstanceId, null); return; } var valueType = newValue.GetType(); if (variable.MetaData.EventType != null) { if (!TypeHelper.IsSubclassOrImplementsInterface( newValue.GetType(), variable.MetaData.EventType.UnderlyingType)) { throw new VariableValueException( "Variable '" + variableName + "' of declared event type '" + variable.MetaData.EventType.Name + "' underlying type '" + variable.MetaData.EventType.UnderlyingType.CleanName() + "' cannot be assigned a value of type '" + valueType.Name + "'"); } var eventBean = eventBeanTypedEventFactory.AdapterForTypedObject(newValue, variable.MetaData.EventType); Write(variableNumber, agentInstanceId, eventBean); return; } var variableType = variable.MetaData.Type; if (valueType.Equals(variableType) || variableType == typeof(object)) { Write(variableNumber, agentInstanceId, newValue); return; } if (TypeHelper.IsSubclassOrImplementsInterface(valueType, variableType)) { Write(variableNumber, agentInstanceId, newValue); return; } if (!variableType.IsNumeric() || !valueType.IsNumeric()) { throw new VariableValueException( VariableUtil.GetAssigmentExMessage(variableName, variableType, valueType)); } // determine if the expression type can be assigned if (!valueType.CanCoerce(variableType)) { throw new VariableValueException( VariableUtil.GetAssigmentExMessage(variableName, variableType, valueType)); } var valueCoerced = TypeHelper.CoerceBoxed(newValue, variableType); Write(variableNumber, agentInstanceId, valueCoerced); }
public void AllocateVariableState( string deploymentId, string variableName, int agentInstanceId, bool recovery, NullableObject<object> initialValue, EventBeanTypedEventFactory eventBeanTypedEventFactory) { var entry = DeploymentsWithVariables.Get(deploymentId); if (entry == null) { throw new ArgumentException("Failed to find variable deployment id '" + deploymentId + "'"); } var variable = entry.GetVariable(variableName); if (variable == null) { throw new ArgumentException("Failed to find variable '" + variableName + "'"); } // Check current state - see if the variable exists in the state handler object initialState; if (initialValue != null) { initialState = initialValue.Value; } else { initialState = variable.MetaData.ValueWhenAvailable; } if (variable.MetaData.EventType != null && initialState != null && !(initialState is EventBean)) { initialState = eventBeanTypedEventFactory.AdapterForTypedObject( initialState, variable.MetaData.EventType); } if (OptionalStateHandler != null && !variable.MetaData.IsConstant) { var priorValue = OptionalStateHandler.GetHasState(variable, agentInstanceId); if (recovery) { if (priorValue != null) { initialState = priorValue.Value; } } else { if (priorValue == null) { // we do not already have a value OptionalStateHandler.SetState(variable, agentInstanceId, initialState); } else { initialState = priorValue.Value; } } } // create new holder for versions var timestamp = timeProvider.Time; var valuePerVersion = new VersionedValueList<object>( variableName, currentVersionNumber, initialState, timestamp, millisecondLifetimeOldVersions, ReadWriteLock.ReadLock, HIGH_WATERMARK_VERSIONS, false); IDictionary<int, VariableReader> cps = variableVersionsPerCP[variable.VariableNumber]; var reader = new VariableReader(variable, versionThreadLocal, valuePerVersion); cps.Put(agentInstanceId, reader); }
public EventBean Make(object[] propertyValues) { var outObject = MakeUnderlying(propertyValues); return service.AdapterForTypedObject(outObject, beanEventType); }