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);
}
