public WriteDesc(EventTypeSPI type, String variableName, EventPropertyWriter writer, EventPropertyGetter getter)
{
Type = type;
VariableName = variableName;
Writer = writer;
Getter = getter;
}
public EventPropertyDescriptor GetWritableProperty(string propertyName)
{
foreach (EventPropertyDescriptor desc in _propertyDescriptors)
{
if (desc.PropertyName.Equals(propertyName))
{
return desc;
}
}
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (property is MappedProperty)
{
EventPropertyWriter writer = GetWriter(propertyName);
if (writer == null)
{
return null;
}
var mapProp = (MappedProperty) property;
return new EventPropertyDescriptor(
mapProp.PropertyNameAtomic, typeof (Object), null, false, true, false, true, false);
}
if (property is IndexedProperty)
{
EventPropertyWriter writer = GetWriter(propertyName);
if (writer == null)
{
return null;
}
var indexedProp = (IndexedProperty) property;
return new EventPropertyDescriptor(
indexedProp.PropertyNameAtomic, typeof (Object), null, true, false, true, false, false);
}
return null;
}
public override EventPropertyDescriptor GetWritableProperty(string propertyName)
{
if (_writablePropertyDescriptors == null)
{
InitializeWriters();
}
var pair = _propertyWriters.Get(propertyName);
if (pair != null)
{
return(pair.First);
}
var property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (property is MappedProperty mapProp)
{
EventPropertyWriter writer = GetWriter(propertyName);
return(writer != null
? new EventPropertyDescriptor(mapProp.PropertyNameAtomic, typeof(object), null, false, true, false, true, false)
: null);
}
if (property is IndexedProperty indexedProp)
{
EventPropertyWriter writer = GetWriter(propertyName);
return(writer != null
? new EventPropertyDescriptor(indexedProp.PropertyNameAtomic, typeof(object), null, true, false, true, false, false)
: null);
}
return(null);
}
public BeaconSourceOp(
BeaconSourceFactory factory,
long iterations,
long initialDelayMSec,
long periodDelayMSec,
IDictionary<string, object> additionalParameters)
{
this.factory = factory;
this.iterations = iterations;
this.initialDelayMSec = initialDelayMSec;
this.periodDelayMSec = periodDelayMSec;
if (additionalParameters != null) {
additionalProperties = new Pair<EventPropertyWriter, object>[additionalParameters.Count];
var count = 0;
foreach (var param in additionalParameters) {
EventPropertyWriter writer = ((EventTypeSPI) factory.OutputEventType).GetWriter(param.Key);
if (writer == null) {
throw new EPException(
"Failed to find writer for property '" + param.Key + "' for event type '" + factory.OutputEventType.Name + "'");
}
additionalProperties[count++] = new Pair<EventPropertyWriter, object>(writer, param.Value);
}
}
}
public EventBeanWriter GetWriter(String[] properties)
{
if (_writableProperties == null)
{
InitializeWriters();
}
bool isOnlyMap = true;
for (int i = 0; i < properties.Length; i++)
{
if (!_writers.ContainsKey(properties[i]))
{
return(null);
}
if (_underlyingMapType.GetWritableProperty(properties[i]) == null)
{
isOnlyMap = false;
}
}
bool isOnlyUnderlying = true;
if (!isOnlyMap)
{
var spi = (EventTypeSPI)_underlyingEventType;
for (int i = 0; i < properties.Length; i++)
{
if (spi.GetWritableProperty(properties[i]) == null)
{
isOnlyUnderlying = false;
}
}
}
if (isOnlyMap)
{
return(new WrapperEventBeanMapWriter(properties));
}
if (isOnlyUnderlying)
{
var spi = (EventTypeSPI)_underlyingEventType;
var undWriter = spi.GetWriter(properties);
if (undWriter == null)
{
return(undWriter);
}
return(new WrapperEventBeanUndWriter(undWriter));
}
var writerArr = new EventPropertyWriter[properties.Length];
for (int i = 0; i < properties.Length; i++)
{
writerArr[i] = _writers.Get(properties[i]).Second;
}
return(new WrapperEventBeanPropertyWriter(writerArr));
}
public EventBeanUpdateItem(
ExprEvaluator expression,
string optinalPropertyName,
EventPropertyWriter optionalWriter,
bool notNullableField,
TypeWidener optionalWidener)
{
Expression = expression;
OptionalPropertyName = optinalPropertyName;
OptionalWriter = optionalWriter;
IsNotNullableField = notNullableField;
OptionalWidener = optionalWidener;
}
public EventPropertyDescriptor GetWritableProperty(string propertyName)
{
if (_writeablePropertyDescriptors == null)
{
InitializeWriters();
}
Pair<EventPropertyDescriptor, BeanEventPropertyWriter> pair = _writerMap.Get(propertyName);
if (pair != null)
{
return pair.First;
}
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (property is MappedProperty)
{
EventPropertyWriter writer = GetWriter(propertyName);
if (writer == null)
{
return null;
}
var mapProp = (MappedProperty) property;
return new EventPropertyDescriptor(
mapProp.PropertyNameAtomic, typeof (Object), null, false, true, false, true, false);
}
if (property is IndexedProperty)
{
EventPropertyWriter writer = GetWriter(propertyName);
if (writer == null)
{
return null;
}
var indexedProp = (IndexedProperty) property;
return new EventPropertyDescriptor(
indexedProp.PropertyNameAtomic, typeof (Object), null, true, false, true, false, false);
}
return null;
}
private void InitializeWriters()
{
IList<EventPropertyDescriptor> writables = new List<EventPropertyDescriptor>();
IDictionary<string, Pair<EventPropertyDescriptor, EventPropertyWriterSPI>> writerMap =
new Dictionary<string, Pair<EventPropertyDescriptor, EventPropertyWriterSPI>>();
writables.AddAll(underlyingMapType.WriteableProperties);
foreach (var writableMapProp in underlyingMapType.WriteableProperties) {
var propertyName = writableMapProp.PropertyName;
writables.Add(writableMapProp);
EventPropertyWriterSPI writer = new ProxyEventPropertyWriterSPI {
ProcWrite = (
value,
target) => {
var decorated = (DecoratingEventBean) target;
decorated.DecoratingProperties.Put(propertyName, value);
},
ProcWriteCodegen = (
assigned,
und,
target,
parent,
classScope) => {
var decorated = Cast(typeof(DecoratingEventBean), target);
var decoratingProps = ExprDotName(decorated, "DecoratingProperties");
return ExprDotMethod(decoratingProps, "Put", Constant(propertyName), assigned);
}
};
writerMap.Put(
propertyName,
new Pair<EventPropertyDescriptor, EventPropertyWriterSPI>(
writableMapProp,
writer));
}
if (underlyingEventType is EventTypeSPI) {
var spi = (EventTypeSPI) underlyingEventType;
foreach (var writableUndProp in spi.WriteableProperties) {
var propertyName = writableUndProp.PropertyName;
EventPropertyWriter innerWriter = spi.GetWriter(propertyName);
if (innerWriter == null) {
continue;
}
writables.Add(writableUndProp);
EventPropertyWriterSPI writer = new ProxyEventPropertyWriterSPI {
ProcWrite = (
value,
target) => {
var decorated = (DecoratingEventBean) target;
innerWriter.Write(value, decorated.UnderlyingEvent);
},
ProcWriteCodegen = (
assigned,
und,
target,
parent,
classScope) => {
var decorated = Cast(typeof(DecoratingEventBean), target);
var underlyingBean = ExprDotName(decorated, "UnderlyingEvent");
var underlying = ExprDotName(underlyingBean, "Underlying");
var casted = Cast(underlyingEventType.UnderlyingType, underlying);
return ((EventPropertyWriterSPI) innerWriter).WriteCodegen(
assigned,
casted,
target,
parent,
classScope);
}
};
writerMap.Put(
propertyName,
new Pair<EventPropertyDescriptor, EventPropertyWriterSPI>(
writableUndProp,
writer));
}
}
writers = writerMap;
writableProperties = writables.ToArray();
}
