/// <summary>
/// Ctor.
/// </summary>
/// <param name="objectArrayEventType">map event type</param>
/// <param name="eventAdapterService">for copying events</param>
public ObjectArrayEventBeanCopyMethod(
ObjectArrayEventType objectArrayEventType,
EventBeanTypedEventFactory eventAdapterService)
{
this.objectArrayEventType = objectArrayEventType;
this.eventAdapterService = eventAdapterService;
}
public ExprDotStaticMethodWrapIterableEvents(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventType type)
{
this.eventBeanTypedEventFactory = eventBeanTypedEventFactory;
this.type = type;
}
protected abstract AvroSchemaEventType MakeType(
EventTypeMetadata metadata,
EventBeanTypedEventFactory eventAdapterService,
Schema schema,
ConfigurationCommonEventTypeAvro optionalConfig,
EventType[] supertypes,
ISet<EventType> deepSupertypes);
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="value">value</param>
/// <param name="eventAdapterService">svc</param>
/// <param name="fragmentType">type</param>
/// <returns>fragment</returns>
public static object GetFragmentAvro(
object value,
EventBeanTypedEventFactory eventAdapterService,
EventType fragmentType)
{
if (fragmentType == null) {
return null;
}
if (value is GenericRecord) {
return eventAdapterService.AdapterForTypedAvro(value, fragmentType);
}
if (value is ICollection<object> valueAsCollection) {
var events = new EventBean[valueAsCollection.Count];
var index = 0;
foreach (var item in valueAsCollection) {
events[index++] = eventAdapterService.AdapterForTypedAvro(item, fragmentType);
}
return events;
}
return null;
}
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;
}
public override MapEventPropertyGetter GetGetterMap(
IDictionary<string, object> optionalMapPropTypes,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
return new MapIndexedPropertyGetter(PropertyNameAtomic, Index);
}
/// <summary>
/// Make a wrapper type.
/// A wrapper event type may indeed wrap another wrapper event type. This is so that a wrapper event bean can wrap
/// another wrapper event bean.
/// If there were unwrapped the nesting information such as what is the nested wrapper type and how they are nested
/// would be lost.
/// </summary>
/// <param name="metadata">metadata</param>
/// <param name="underlyingEventType">underlying event type</param>
/// <param name="propertyTypesMayPrimitive">property types</param>
/// <param name="eventBeanTypedEventFactory">factory for instances</param>
/// <param name="beanEventTypeFactory">bean event type factory</param>
/// <param name="eventTypeNameResolver">type name resolver</param>
/// <returns>wrapper type</returns>
public static WrapperEventType MakeWrapper(
EventTypeMetadata metadata,
EventType underlyingEventType,
IDictionary<string, object> propertyTypesMayPrimitive,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory,
EventTypeNameResolver eventTypeNameResolver)
{
// If we are wrapping an underlying type that is itself a wrapper, then this is a special case
if (underlyingEventType is WrapperEventType underlyingWrapperType) {
// the underlying type becomes the type already wrapped
// properties are a superset of the wrapped properties and the additional properties
underlyingEventType = underlyingWrapperType.UnderlyingEventType;
var propertiesSuperset = new Dictionary<string, object>();
propertiesSuperset.PutAll(underlyingWrapperType.UnderlyingMapType.Types);
propertiesSuperset.PutAll(propertyTypesMayPrimitive);
propertyTypesMayPrimitive = propertiesSuperset;
}
IDictionary<string, object> verified = BaseNestableEventUtil.ResolvePropertyTypes(
propertyTypesMayPrimitive,
eventTypeNameResolver);
return new WrapperEventType(
metadata,
underlyingEventType,
verified,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
public EventPropertyGetterSPI GetGetterRootedDynamicNested(
Property prop,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
throw new IllegalStateException("This getter is not available for object-array events");
}
public override EventPropertyGetterSPI GetGetterDOM(
SchemaElementComplex complexProperty,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BaseXMLEventType xmlEventType,
string propertyExpression)
{
foreach (var attribute in complexProperty.Attributes) {
if (attribute.Name.Equals(PropertyNameAtomic)) {
return new DOMSimpleAttributeGetter(PropertyNameAtomic);
}
}
foreach (var simple in complexProperty.SimpleElements) {
if (simple.Name.Equals(PropertyNameAtomic)) {
return new DOMComplexElementGetter(PropertyNameAtomic, null, simple.IsArray);
}
}
foreach (SchemaElementComplex complex in complexProperty.ComplexElements) {
var complexFragmentFactory = new FragmentFactoryDOMGetter(
eventBeanTypedEventFactory,
xmlEventType,
propertyExpression);
if (complex.Name.Equals(PropertyNameAtomic)) {
return new DOMComplexElementGetter(PropertyNameAtomic, complexFragmentFactory, complex.IsArray);
}
}
return null;
}
private EventPropertyGetterSPI GetGetterFromDictionary(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory,
PropertyStem propertyDesc)
{
if (propertyDesc.AccessorProp != null) {
return new KeyedMapPropertyPropertyGetter(
propertyDesc.AccessorProp,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
if (propertyDesc.IsSimpleReadMethod) {
return new KeyedMapMethodPropertyGetter(
propertyDesc.ReadMethod,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
if (propertyDesc.AccessorField != null) {
var field = propertyDesc.AccessorField;
return new KeyedMapFieldPropertyGetter(
field,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
throw new IllegalStateException($"unable to determine property getter for requested member");
}
// EventPropertyGetterAndMapped
public override EventPropertyGetterSPI GetGetter(
BeanEventType eventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
var propertyDesc = eventType.GetMappedProperty(PropertyNameAtomic);
if (propertyDesc == null) {
return null;
}
if (propertyDesc.IsMappedReadMethod) {
return new KeyedMethodPropertyGetter(
propertyDesc.ReadMethod,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
// Try the as a simple property
if (!propertyDesc.PropertyType.IsSimple()) {
return null;
}
var returnType = propertyDesc.ReturnType;
if (returnType.IsGenericStringDictionary()) {
return GetGetterFromDictionary(
eventBeanTypedEventFactory,
beanEventTypeFactory,
propertyDesc);
}
return null;
}
public override EventPropertyGetterSPI GetGetterDOM(
SchemaElementComplex complexProperty,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BaseXMLEventType eventType,
string propertyExpression)
{
foreach (var simple in complexProperty.SimpleElements) {
if (!simple.IsArray) {
continue;
}
if (!simple.Name.Equals(PropertyNameAtomic)) {
continue;
}
return new DOMIndexedGetter(PropertyNameAtomic, Index, null);
}
foreach (var complex in complexProperty.ComplexElements) {
if (!complex.IsArray) {
continue;
}
if (!complex.Name.Equals(PropertyNameAtomic)) {
continue;
}
return new DOMIndexedGetter(
PropertyNameAtomic,
Index,
new FragmentFactoryDOMGetter(eventBeanTypedEventFactory, eventType, propertyExpression));
}
return null;
}
private EventPropertyGetterSPI GetGetterFromArray(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory,
PropertyStem propertyDesc)
{
var prop = propertyDesc.AccessorProp;
if (prop != null) {
return new ArrayPropertyPropertyGetter(prop, Index, eventBeanTypedEventFactory, beanEventTypeFactory);
}
if (propertyDesc.IsSimpleReadMethod) {
var method = propertyDesc.ReadMethod;
return new ArrayMethodPropertyGetter(
method,
Index,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
var field = propertyDesc.AccessorField;
if (field != null) {
return new ArrayFieldPropertyGetter(field, Index, eventBeanTypedEventFactory, beanEventTypeFactory);
}
throw new EPRuntimeException("unable to determine property array accessor");
}
private EventPropertyGetterSPI GetGetterFromEnumerable(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory,
PropertyStem propertyDesc)
{
if (propertyDesc.AccessorProp != null) {
return new IterablePropertyPropertyGetter(
propertyDesc.AccessorProp,
Index,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
if (propertyDesc.IsSimpleReadMethod) {
return new IterableMethodPropertyGetter(
propertyDesc.ReadMethod,
Index,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
if (propertyDesc.AccessorField != null) {
return new IterableFieldPropertyGetter(
propertyDesc.AccessorField,
Index,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
throw new EPRuntimeException("unable to determine property enumerator accessor");
}
public AvroEventBeanCopyMethod(
AvroEventType avroEventType,
EventBeanTypedEventFactory eventAdapterService)
{
_avroEventType = avroEventType;
_eventAdapterService = eventAdapterService;
}
public JsonGetterSimpleSchemaWFragmentArray(
JsonUnderlyingField field,
string underlyingClassName,
EventType fragmentType,
EventBeanTypedEventFactory eventBeanTypedEventFactory) : base(field, underlyingClassName, fragmentType, eventBeanTypedEventFactory)
{
}
public EventBeanFactoryAvro(
EventType type,
EventBeanTypedEventFactory eventAdapterService)
{
_type = type;
_eventAdapterService = eventAdapterService;
}
/// <summary>
/// Return getter for the given property.
/// </summary>
/// <param name="property">property to resolve</param>
/// <param name="eventBeanTypedEventFactory">factory for event beans and event types</param>
/// <param name="beanEventTypeFactory">bean factory</param>
public static EventPropertyGetterSPI GetGetter(
PropertyInfo property,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
return new ReflectionPropMethodGetter(property, eventBeanTypedEventFactory, beanEventTypeFactory);
}
public JsonEventBeanCopyMethod(
JsonEventType eventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
_eventType = eventType;
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public EventBeanFactoryObjectArray(
EventType type,
EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
this.type = type;
this.eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public EventBeanCopyMethod GetCopyMethod(EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
return new WrapperEventBeanUndCopyMethod(
wrapperEventType,
eventBeanTypedEventFactory,
underlyingCopyMethod.GetCopyMethod(eventBeanTypedEventFactory));
}
public EventBeanManufacturer GetManufacturer(EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
var nativeKeys = _writables.Select(_ => _.PropertyName).ToArray();
//var nativeKeys = EventBeanManufacturerJson.FindPropertyIndexes(_jsonEventType, _writables);
return(new EventBeanManufacturerJson(_jsonEventType, eventBeanTypedEventFactory, nativeKeys));
}
public AvroEventType(
EventTypeMetadata metadata,
Schema avroSchema,
string startTimestampPropertyName,
string endTimestampPropertyName,
EventType[] optionalSuperTypes,
ISet<EventType> deepSupertypes,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTypeAvroHandler eventTypeAvroHandler)
{
Metadata = metadata;
_avroSchema = avroSchema;
_optionalSuperTypes = optionalSuperTypes;
_deepSupertypes = deepSupertypes ?? new EmptySet<EventType>();
_propertyItems = new LinkedHashMap<string, PropertySetDescriptorItem>();
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
_eventTypeAvroHandler = eventTypeAvroHandler;
Init();
var desc = EventTypeUtility.ValidatedDetermineTimestampProps(
this,
startTimestampPropertyName,
endTimestampPropertyName,
optionalSuperTypes);
StartTimestampPropertyName = desc.Start;
EndTimestampPropertyName = desc.End;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="objectArrayEventType">map event type</param>
/// <param name="eventBeanTypedEventFactory">for copying events</param>
public ObjectArrayEventBeanCopyMethodForge(
ObjectArrayEventType objectArrayEventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
this.objectArrayEventType = objectArrayEventType;
this.eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public GetterNestedFactoryRootedSimple(
EventBeanTypedEventFactory eventAdapterService,
Field posTop)
{
_eventAdapterService = eventAdapterService;
_posTop = posTop;
}
public override EventPropertyGetterSPI GetGetter(
BeanEventType eventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
if (!eventType.Stem.IsPublicFields) {
// Determine if there is an "indexed" method matching the form GetXXX(int index)
var underlyingType = eventType.UnderlyingType;
var propertyInfo = eventType.UnderlyingType.GetProperty(PropertyNameAtomic);
if (propertyInfo != null && propertyInfo.CanRead) {
}
return new DynamicMappedPropertyGetterByMethodOrProperty(
PropertyNameAtomic,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
return new DynamicMappedPropertyGetterByField(
PropertyNameAtomic,
Key,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
