public SelectEvalInsertCoercionJson(
JsonEventType source,
JsonEventType target)
{
this.source = source;
this.target = target;
}
public SelectEvalJoinWildcardProcessorJson(
string[] streamNames,
JsonEventType resultEventType)
{
this.streamNames = streamNames;
this.resultEventType = resultEventType;
}
public SelectEvalNoWildcardJson(
SelectExprForgeContext selectContext,
JsonEventType jsonEventType)
{
this._selectContext = selectContext;
this._jsonEventType = jsonEventType;
}
public EventBeanManufacturerJsonForge(
JsonEventType jsonEventType,
WriteablePropertyDescriptor[] writables)
{
_jsonEventType = jsonEventType;
_writables = writables;
}
public EventBeanFactoryJson(
JsonEventType type,
EventBeanTypedEventFactory factory)
{
_type = type;
_factory = factory;
}
public JsonEventBeanCopyMethod(
JsonEventType eventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
_eventType = eventType;
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public static JsonForgeDesc ForgeNonArray(
string fieldName,
JsonEventType other)
{
JsonDeserializerForge deserializerForge = new JsonDeserializerForgeByClassName(
other.Detail.DeserializerClassName);
JsonSerializerForge serializerForge;
if (other.Detail.OptionalUnderlyingProvided == null)
{
serializerForge = new JsonSerializerForgeByMethod("WriteNested");
}
else
{
serializerForge = new ProxyJsonSerializerForge(
(
refs,
method,
classScope) =>
StaticMethod(
typeof(JsonSerializerUtil),
"WriteNested",
refs.Context,
refs.Field,
NewInstanceInner(other.Detail.SerializerClassName)
));
// NewInstanceInner(other.Detail.DeserializerFactoryClassName)));
}
return(new JsonForgeDesc(deserializerForge, serializerForge));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="jsonEventType">target type</param>
/// <param name="service">factory for events</param>
/// <param name="properties">written properties</param>
/// <param name="classpathImportService">for resolving write methods</param>
/// <throws>EventBeanManufactureException if the write method lookup fail</throws>
public EventBeanManufacturerJsonProvided(
JsonEventType jsonEventType,
EventBeanTypedEventFactory service,
WriteablePropertyDescriptor[] properties,
ImportService classpathImportService)
{
this._jsonEventType = jsonEventType;
this._service = service;
_beanInstantiator = new BeanInstantiatorForgeByNewInstanceReflection(jsonEventType.UnderlyingType);
_writeFieldsReflection = new FieldInfo[properties.Length];
var primitiveTypeCheck = false;
_primitiveType = new bool[properties.Length];
for (var i = 0; i < properties.Length; i++)
{
var propertyName = properties[i].PropertyName;
var field = jsonEventType.Detail.FieldDescriptors.Get(propertyName);
_writeFieldsReflection[i] = field.OptionalField;
_primitiveType[i] = properties[i].PropertyType.IsPrimitive;
primitiveTypeCheck |= _primitiveType[i];
}
_hasPrimitiveTypes = primitiveTypeCheck;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="jsonEventType">type to create</param>
/// <param name="eventAdapterService">event factory</param>
/// <param name="nativeKeys">native keys</param>
public EventBeanManufacturerJson(
JsonEventType jsonEventType,
EventBeanTypedEventFactory eventAdapterService,
string[] nativeKeys)
{
_eventAdapterService = eventAdapterService;
_jsonEventType = jsonEventType;
_nativeKeys = nativeKeys;
}
internal JsonInsertProcessorStraightFieldAssign(
int underlyingStreamNumber,
JsonEventType sourceType,
JsonEventType resultType)
{
this.underlyingStreamNumber = underlyingStreamNumber;
this.sourceType = sourceType;
this.resultType = resultType;
}
private static IDictionary <string, JsonUnderlyingField> ComputeFields(
IDictionary <string, object> compiledTyping,
IDictionary <string, string> fieldNames,
JsonEventType optionalSuperType,
IDictionary <string, FieldInfo> fields)
{
IDictionary <string, JsonUnderlyingField> allFieldsInclSupertype = new LinkedHashMap <string, JsonUnderlyingField>();
var index = 0;
if (optionalSuperType != null)
{
allFieldsInclSupertype.PutAll(optionalSuperType.Detail.FieldDescriptors);
index = allFieldsInclSupertype.Count;
}
foreach (var entry in compiledTyping)
{
var propertyName = entry.Key;
var fieldName = fieldNames.Get(entry.Key);
var type = entry.Value;
Type assignedType;
if (type == null)
{
assignedType = typeof(object);
}
else if (type is Type)
{
assignedType = (Type)type;
}
else if (type is TypeBeanOrUnderlying)
{
var other = ((TypeBeanOrUnderlying)type).EventType;
ValidateJsonOrMapType(other);
assignedType = GetAssignedType(other);
}
else if (type is TypeBeanOrUnderlying[])
{
var other = ((TypeBeanOrUnderlying[])type)[0].EventType;
ValidateJsonOrMapType(other);
assignedType = TypeHelper.GetArrayType(GetAssignedType(other));
}
else
{
throw new IllegalStateException("Unrecognized type " + type);
}
allFieldsInclSupertype.Put(entry.Key, new JsonUnderlyingField(
fieldName, propertyName, assignedType, fields.Get(fieldName)));
index++;
}
return(allFieldsInclSupertype);
}
internal static int[] FindPropertyIndexes(
JsonEventType jsonEventType,
WriteablePropertyDescriptor[] writables)
{
var nativeNums = new int[writables.Length];
for (var i = 0; i < writables.Length; i++) {
nativeNums[i] = FindPropertyIndex(jsonEventType, writables[i].PropertyName);
}
return nativeNums;
}
internal JsonInsertProcessorExpressions(
int underlyingStreamNumber,
Item[] items,
JsonEventType sourceType,
JsonEventType resultType)
{
this.underlyingStreamNumber = underlyingStreamNumber;
this.items = items;
this.sourceType = sourceType;
this.resultType = resultType;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="runtimeEventSender">for processing events</param>
/// <param name="eventType">the event type</param>
/// <param name="threadingService">for inbound threading</param>
/// <param name="eventBeanTypedEventFactory">for event bean creation</param>
public EventSenderJsonImpl(
EPRuntimeEventProcessWrapped runtimeEventSender,
JsonEventType eventType,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
ThreadingCommon threadingService)
{
_runtimeEventSender = runtimeEventSender;
_eventType = eventType;
_threadingService = threadingService;
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
private static bool DetermineDynamic(
JsonSchemaAttribute jsonSchema,
JsonEventType optionalSuperType,
StatementRawInfo raw)
{
if (optionalSuperType != null && optionalSuperType.Detail.IsDynamic)
{
return(true);
}
return(jsonSchema != null && jsonSchema.Dynamic);
}
public StmtClassForgeableJsonDesc(
IDictionary<string, object> propertiesThisType,
IDictionary<string, JsonUnderlyingField> fieldDescriptorsInclSupertype,
bool dynamic,
int numFieldsSupertype,
JsonEventType optionalSupertype,
IDictionary<string, JsonForgeDesc> forges)
{
PropertiesThisType = propertiesThisType;
FieldDescriptorsInclSupertype = fieldDescriptorsInclSupertype;
IsDynamic = dynamic;
NumFieldsSupertype = numFieldsSupertype;
OptionalSupertype = optionalSupertype;
Forges = forges;
}
internal static int FindPropertyIndex(
JsonEventType jsonEventType,
string propertyName)
{
var types = jsonEventType.Types;
var index = 0;
foreach (var entry in types) {
if (entry.Key.Equals(propertyName)) {
return index;
}
index++;
}
throw new IllegalStateException("Failed to find writable property '" + propertyName + "'");
}
public static Type GetNestedUnderlyingType(
JsonEventType eventType,
string propertyName)
{
object type = eventType.Types.Get(propertyName);
EventType innerType;
if (type is TypeBeanOrUnderlying)
{
innerType = ((TypeBeanOrUnderlying)type).EventType;
}
else
{
innerType = ((TypeBeanOrUnderlying[])type)[0].EventType;
}
return(innerType.UnderlyingType);
}
public void RegisterJson(
EventTypeMetadata metadata,
IDictionary<string, object> properties,
string[] superTypes,
string startTimestampPropertyName,
string endTimestampPropertyName,
JsonEventTypeDetail detail)
{
JsonEventType eventType = _eventTypeFactory.CreateJson(
metadata,
properties,
superTypes,
startTimestampPropertyName,
endTimestampPropertyName,
_beanEventTypeFactory,
_eventTypeNameResolver,
detail);
eventType.Initialize(_classLoader);
HandleRegister(eventType);
}
public static JsonEventType MakeJsonTypeCompileTimeExistingType(
EventTypeMetadata metadata,
JsonEventType existingType,
StatementCompileTimeServices services)
{
var getterFactoryJson = new EventTypeNestableGetterFactoryJson(existingType.Detail);
return(new JsonEventType(
metadata,
existingType.Types,
null,
EmptySet <EventType> .Instance,
existingType.StartTimestampPropertyName,
existingType.EndTimestampPropertyName,
getterFactoryJson,
services.BeanEventTypeFactoryPrivate,
existingType.Detail,
existingType.UnderlyingType,
existingType.UnderlyingTypeIsTransient));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="jsonEventType">target type</param>
/// <param name="properties">written properties</param>
/// <param name="importService">for resolving write methods</param>
/// <throws>EventBeanManufactureException if the write method lookup fail</throws>
public EventBeanManufacturerJsonProvidedForge(
JsonEventType jsonEventType,
WriteablePropertyDescriptor[] properties,
ImportService importService)
{
_jsonEventType = jsonEventType;
_properties = properties;
_importService = importService;
_beanInstantiator = new BeanInstantiatorForgeByNewInstanceReflection(jsonEventType.UnderlyingType);
_writeFieldReflection = new FieldInfo[properties.Length];
_primitiveType = new bool[properties.Length];
for (var i = 0; i < properties.Length; i++)
{
var propertyName = properties[i].PropertyName;
var field = jsonEventType.Detail.FieldDescriptors.Get(propertyName);
_writeFieldReflection[i] = field.OptionalField;
_primitiveType[i] = properties[i].PropertyType.IsPrimitive;
}
}
public static JsonForgeDesc ForgeArray(
string fieldName,
JsonEventType other)
{
var deserializerForge = new JsonDeserializerForgeArray(
new JsonDeserializerForgeByClassName(other.Detail.DeserializerClassName),
other.UnderlyingType);
// JsonAllocatorForge startArray = new JsonAllocatorForgeWithAllocatorFactoryArray(
// other.Detail.DeserializerFactoryClassName,
// other.UnderlyingType);
// JsonEndValueForge end = new JsonEndValueForgeCast(TypeHelper.GetArrayType(other.UnderlyingType));
JsonSerializerForge serializerForge;
if (other.Detail.OptionalUnderlyingProvided == null)
{
serializerForge = new JsonSerializerForgeByMethod("WriteNestedArray");
}
else
{
serializerForge = new ProxyJsonSerializerForge(
(
refs,
method,
classScope) =>
StaticMethod(
typeof(JsonSerializerUtil),
"WriteNestedArray",
refs.Context,
refs.Field,
NewInstanceInner(other.Detail.SerializerClassName)
));
}
return(new JsonForgeDesc(deserializerForge, serializerForge));
}
// The create window command:
// create window windowName[.window_view_list] as [select properties from] type
//
// This section expected s single FilterStreamSpecCompiled representing the selected type.
// It creates a new event type representing the window type and a sets the type selected on the filter stream spec.
protected internal static CreateWindowCompileResult HandleCreateWindow(
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc;
var columns = createWindowDesc.Columns;
var typeName = createWindowDesc.WindowName;
EventType targetType;
// determine that the window name is not already in use as an event type name
var existingType = services.EventTypeCompileTimeResolver.GetTypeByName(typeName);
if (existingType != null && existingType.Metadata.TypeClass != EventTypeTypeClass.NAMED_WINDOW) {
throw new ExprValidationException(
"Error starting statement: An event type or schema by name '" + typeName + "' already exists");
}
// Determine select-from
var optionalSelectFrom = GetOptionalSelectFrom(createWindowDesc, services);
// Create Map or Wrapper event type from the select clause of the window.
// If no columns selected, simply create a wrapper type
// Build a list of properties
var newSelectClauseSpecRaw = new SelectClauseSpecRaw();
LinkedHashMap<string, object> properties;
var hasProperties = false;
if (columns != null && !columns.IsEmpty()) {
properties = EventTypeUtility.BuildType(
columns,
null,
services.ImportServiceCompileTime,
services.EventTypeCompileTimeResolver);
hasProperties = true;
}
else {
if (optionalSelectFrom == null) {
throw new IllegalStateException("Missing from-type information for create-window");
}
// Validate the select expressions which consists of properties only
var select = CompileLimitedSelect(optionalSelectFrom, @base, services);
properties = new LinkedHashMap<string, object>();
foreach (var selectElement in select) {
if (selectElement.FragmentType != null) {
properties.Put(selectElement.AssignedName, selectElement.FragmentType);
}
else {
properties.Put(selectElement.AssignedName, selectElement.SelectExpressionType);
}
// Add any properties to the new select clause for use by consumers to the statement itself
newSelectClauseSpecRaw.Add(
new SelectClauseExprRawSpec(new ExprIdentNodeImpl(selectElement.AssignedName), null, false));
hasProperties = true;
}
}
// Create Map or Wrapper event type from the select clause of the window.
// If no columns selected, simply create a wrapper type
var isOnlyWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsOnlyWildcard;
var isWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsUsingWildcard;
var namedWindowVisibility = services.ModuleVisibilityRules.GetAccessModifierNamedWindow(@base, typeName);
var additionalForgeables = new List<StmtClassForgeableFactory>();
try {
if (isWildcard && !isOnlyWildcard) {
var metadata = new EventTypeMetadata(
typeName,
@base.ModuleName,
EventTypeTypeClass.NAMED_WINDOW,
EventTypeApplicationType.WRAPPER,
namedWindowVisibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
targetType = WrapperEventTypeUtil.MakeWrapper(
metadata,
optionalSelectFrom.EventType,
properties,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else {
// Some columns selected, use the types of the columns
Func<EventTypeApplicationType, EventTypeMetadata> metadata = type => new EventTypeMetadata(
typeName,
@base.ModuleName,
EventTypeTypeClass.NAMED_WINDOW,
type,
namedWindowVisibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
if (hasProperties && !isOnlyWildcard) {
var compiledProperties = EventTypeUtility.CompileMapTypeProperties(
properties,
services.EventTypeCompileTimeResolver);
var representation = EventRepresentationUtil.GetRepresentation(
@base.StatementSpec.Annotations,
services.Configuration,
AssignedType.NONE);
if (representation == EventUnderlyingType.MAP) {
targetType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
compiledProperties,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.OBJECTARRAY) {
targetType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
compiledProperties,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.AVRO) {
targetType = services.EventTypeAvroHandler.NewEventTypeFromNormalized(
metadata.Invoke(EventTypeApplicationType.AVRO),
services.EventTypeCompileTimeResolver,
services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory,
compiledProperties,
@base.StatementRawInfo.Annotations,
null,
null,
null,
@base.StatementName);
} else if (representation == EventUnderlyingType.JSON) {
EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType(
metadata.Invoke(EventTypeApplicationType.JSON),
compiledProperties,
null,
null,
@base.StatementRawInfo,
services);
targetType = pair.EventType;
additionalForgeables.AddRange(pair.AdditionalForgeables);
}
else {
throw new IllegalStateException("Unrecognized representation " + representation);
}
}
else {
if (optionalSelectFrom == null) {
throw new IllegalStateException("Missing from-type information for create-window");
}
var selectFromType = optionalSelectFrom.EventType;
// No columns selected, no wildcard, use the type as is or as a wrapped type
if (selectFromType is ObjectArrayEventType) {
var oaType = (ObjectArrayEventType) selectFromType;
targetType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
oaType.Types,
null,
null,
oaType.StartTimestampPropertyName,
oaType.EndTimestampPropertyName,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (selectFromType is AvroSchemaEventType) {
var avroSchemaEventType = (AvroSchemaEventType) selectFromType;
var avro = new ConfigurationCommonEventTypeAvro();
avro.AvroSchema = avroSchemaEventType.Schema;
targetType = services.EventTypeAvroHandler.NewEventTypeFromSchema(
metadata.Invoke(EventTypeApplicationType.AVRO),
services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory,
avro,
null,
null);
} else if (selectFromType is JsonEventType) {
JsonEventType jsonType = (JsonEventType) selectFromType;
targetType = JsonEventTypeUtility.MakeJsonTypeCompileTimeExistingType(
metadata.Invoke(EventTypeApplicationType.JSON),
jsonType,
services);
}
else if (selectFromType is MapEventType) {
var mapType = (MapEventType) selectFromType;
targetType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
mapType.Types,
null,
null,
mapType.StartTimestampPropertyName,
mapType.EndTimestampPropertyName,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (selectFromType is BeanEventType) {
var beanType = (BeanEventType) selectFromType;
targetType = new BeanEventType(
services.Container,
beanType.Stem,
metadata.Invoke(EventTypeApplicationType.CLASS),
services.BeanEventTypeFactoryPrivate,
null,
null,
beanType.StartTimestampPropertyName,
beanType.EndTimestampPropertyName);
}
else {
targetType = WrapperEventTypeUtil.MakeWrapper(
metadata.Invoke(EventTypeApplicationType.WRAPPER),
selectFromType,
new Dictionary<string, object>(),
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
}
}
services.EventTypeCompileTimeRegistry.NewType(targetType);
}
catch (EPException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var filter = new FilterSpecCompiled(targetType, typeName, FilterSpecPlanForge.EMPTY, null);
return new CreateWindowCompileResult(
filter,
newSelectClauseSpecRaw,
optionalSelectFrom?.EventType,
additionalForgeables);
}
public static EventTypeForgeablesPair MakeJsonTypeCompileTimeNewType(
EventTypeMetadata metadata,
IDictionary <string, object> compiledTyping,
Pair <EventType[], ISet <EventType> > superTypes,
ConfigurationCommonEventTypeWithSupertype config,
StatementRawInfo raw,
StatementCompileTimeServices services)
{
if (metadata.ApplicationType != EventTypeApplicationType.JSON)
{
throw new IllegalStateException("Expected Json application type");
}
// determine supertype
var optionalSuperType = (JsonEventType)
(superTypes == null
? null
: (superTypes.First == null || superTypes.First.Length == 0
? null
: superTypes.First[0]));
var numFieldsSuperType = optionalSuperType?.Detail.FieldDescriptors.Count ?? 0;
// determine dynamic
var jsonSchema = (JsonSchemaAttribute)AnnotationUtil.FindAnnotation(raw.Annotations, typeof(JsonSchemaAttribute));
var dynamic = DetermineDynamic(jsonSchema, optionalSuperType, raw);
// determine json underlying type class
var optionalUnderlyingProvided = DetermineUnderlyingProvided(jsonSchema, services);
// determine properties
IDictionary <string, object> properties;
IDictionary <string, string> fieldNames;
IDictionary <Type, JsonApplicationClassSerializationDesc> deepClasses;
IDictionary <string, FieldInfo> fields;
if (optionalUnderlyingProvided == null)
{
properties = ResolvePropertyTypes(compiledTyping, services.EventTypeCompileTimeResolver);
properties = RemoveEventBeanTypes(properties);
fieldNames = ComputeFieldNames(properties);
deepClasses = JsonEventTypeUtilityReflective.ComputeClassesDeep(properties, metadata.Name, raw.Annotations, services);
fields = EmptyDictionary <string, FieldInfo> .Instance;
}
else
{
if (dynamic)
{
throw new ExprValidationException("The dynamic flag is not supported when used with a provided JSON event class");
}
if (optionalSuperType != null)
{
throw new ExprValidationException("Specifying a supertype is not supported with a provided JSON event class");
}
if (!optionalUnderlyingProvided.IsPublic && !optionalUnderlyingProvided.IsNestedPublic)
{
throw new ExprValidationException("Provided JSON event class is not public");
}
if (!optionalUnderlyingProvided.HasDefaultConstructor())
{
throw new ExprValidationException("Provided JSON event class does not have a public default constructor or is a non-static inner class");
}
deepClasses = JsonEventTypeUtilityReflective.ComputeClassesDeep(optionalUnderlyingProvided, metadata.Name, raw.Annotations, services);
fields = new LinkedHashMap <string, FieldInfo>();
deepClasses.Get(optionalUnderlyingProvided).Fields.ForEach(field => fields.Put(field.Name, field));
properties = ResolvePropertiesFromFields(fields);
fieldNames = ComputeFieldNamesFromProperties(properties);
compiledTyping = ResolvePropertyTypes(compiledTyping, services.EventTypeCompileTimeResolver);
ValidateFieldTypes(optionalUnderlyingProvided, fields, compiledTyping);
// use the rich-type definition for properties that may come from events
foreach (var compiledTypingEntry in compiledTyping)
{
if (compiledTypingEntry.Value is TypeBeanOrUnderlying || compiledTypingEntry.Value is TypeBeanOrUnderlying[])
{
properties.Put(compiledTypingEntry.Key, compiledTypingEntry.Value);
}
}
}
var fieldDescriptors = ComputeFields(properties, fieldNames, optionalSuperType, fields);
// Computes a forge for each property presented.
var forgesByProperty = ComputeValueForges(properties, fields, deepClasses, raw.Annotations, services);
// Determines a name for the internal class representation for this json event.
var jsonClassNameSimple = DetermineJsonClassName(metadata, raw, optionalUnderlyingProvided);
var forgeableDesc = new StmtClassForgeableJsonDesc(properties, fieldDescriptors, dynamic, numFieldsSuperType, optionalSuperType, forgesByProperty);
var underlyingClassNameSimple = jsonClassNameSimple;
var underlyingClassNameForReference = optionalUnderlyingProvided != null
? optionalUnderlyingProvided.Name
: underlyingClassNameSimple;
var underlyingClassNameFull = optionalUnderlyingProvided == null
? $"{services.Namespace}.{underlyingClassNameSimple}"
: optionalUnderlyingProvided.FullName;
var underlying = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonUnderlying(
underlyingClassNameSimple,
underlyingClassNameFull,
namespaceScope,
forgeableDesc)
};
var delegateClassNameSimple = jsonClassNameSimple + "__Delegate";
var @delegate = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonDelegate(
CodegenClassType.JSONDELEGATE,
delegateClassNameSimple,
namespaceScope,
underlyingClassNameFull,
forgeableDesc)
};
var deserializerClassNameSimple = jsonClassNameSimple + "__Deserializer";
var deserializer = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonDeserializer(
CodegenClassType.JSONDESERIALIZER,
deserializerClassNameSimple,
namespaceScope,
underlyingClassNameFull,
forgeableDesc)
};
var serializerClassNameSimple = jsonClassNameSimple + "__Serializer";
var serializer = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonSerializer(
CodegenClassType.JSONSERIALIZER,
serializerClassNameSimple,
optionalUnderlyingProvided != null,
namespaceScope,
underlyingClassNameFull,
forgeableDesc)
};
var serializerClassNameFull = $"{services.Namespace}.{serializerClassNameSimple}";
var deserializerClassNameFull = $"{services.Namespace}.{deserializerClassNameSimple}";
var delegateClassNameFull = $"{services.Namespace}.{delegateClassNameSimple}";
// include event type name as underlying-class may occur multiple times
var serdeClassNameFull = $"{services.Namespace}.{jsonClassNameSimple}__{metadata.Name}__Serde";
var detail = new JsonEventTypeDetail(
underlyingClassNameFull,
optionalUnderlyingProvided,
delegateClassNameFull,
deserializerClassNameFull,
serializerClassNameFull,
serdeClassNameFull,
fieldDescriptors,
dynamic,
numFieldsSuperType);
var getterFactoryJson = new EventTypeNestableGetterFactoryJson(detail);
var isStandIn = optionalUnderlyingProvided == null;
var standIn = isStandIn
? services.CompilerServices.CompileStandInClass(CodegenClassType.JSONEVENT, underlyingClassNameSimple, services.Services)
: optionalUnderlyingProvided;
var eventType = new JsonEventType(
metadata,
properties,
superTypes == null ? new EventType[0] : superTypes.First,
superTypes == null ? EmptySet <EventType> .Instance : superTypes.Second,
config?.StartTimestampPropertyName,
config?.EndTimestampPropertyName,
getterFactoryJson,
services.BeanEventTypeFactoryPrivate,
detail,
standIn,
isStandIn);
var additionalForgeables = new List <StmtClassForgeableFactory>();
// generate serializer, deserializer, and delegate forgeables for application classes
GenerateApplicationClassForgables(
optionalUnderlyingProvided, deepClasses, additionalForgeables, raw.Annotations, services);
if (optionalUnderlyingProvided == null)
{
additionalForgeables.Add(underlying);
}
additionalForgeables.Add(@delegate);
additionalForgeables.Add(deserializer);
additionalForgeables.Add(serializer);
return(new EventTypeForgeablesPair(eventType, additionalForgeables));
}
private static CodegenMethod RegisterEventTypeCodegen(
EventType eventType,
CodegenMethodScope parent,
CodegenClassScope classScope,
ModuleEventTypeInitializeSymbol symbols)
{
var method = parent.MakeChild(typeof(void), typeof(EPCompilerImpl), classScope);
// metadata
method.Block.DeclareVar<EventTypeMetadata>("metadata", eventType.Metadata.ToExpression());
if (eventType is JsonEventType) {
JsonEventType jsonEventType = (JsonEventType) eventType;
method.Block.DeclareVar<LinkedHashMap<string, object>>(
"props",
LocalMethod(
MakePropsCodegen(
jsonEventType.Types,
method,
symbols,
classScope,
() => jsonEventType.DeepSuperTypes.GetEnumerator())));
string[] superTypeNames = GetSupertypeNames(jsonEventType);
var detailExpr = jsonEventType.Detail.ToExpression(method, classScope);
method.Block.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleEventTypeInitServicesConstants.GETEVENTTYPECOLLECTOR)
.Add(
"RegisterJson",
Ref("metadata"),
Ref("props"),
Constant(superTypeNames),
Constant(jsonEventType.StartTimestampPropertyName),
Constant(jsonEventType.EndTimestampPropertyName),
detailExpr));
}
else if (eventType is BaseNestableEventType baseNestable) {
method.Block.DeclareVar<LinkedHashMap<string, object>>(
"props",
LocalMethod(
MakePropsCodegen(
baseNestable.Types,
method,
symbols,
classScope,
() => baseNestable.DeepSuperTypes.GetEnumerator())));
var registerMethodName = baseNestable is MapEventType ? "RegisterMap" : "RegisterObjectArray";
var superTypeNames = GetSupertypeNames(baseNestable);
method.Block
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleEventTypeInitServicesConstants.GETEVENTTYPECOLLECTOR)
.Add(
registerMethodName,
Ref("metadata"),
Ref("props"),
Constant(superTypeNames),
Constant(baseNestable.StartTimestampPropertyName),
Constant(baseNestable.EndTimestampPropertyName)));
}
else if (eventType is WrapperEventType wrapper) {
method.Block.DeclareVar<EventType>(
"inner",
EventTypeUtility.ResolveTypeCodegen(wrapper.UnderlyingEventType, symbols.GetAddInitSvc(method)));
method.Block.DeclareVar<LinkedHashMap<string, object>>(
"props",
LocalMethod(
MakePropsCodegen(
wrapper.UnderlyingMapType.Types,
method,
symbols,
classScope,
() => wrapper.UnderlyingMapType.DeepSuperTypes.GetEnumerator())));
method.Block
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleEventTypeInitServicesConstants.GETEVENTTYPECOLLECTOR)
.Add("RegisterWrapper", Ref("metadata"), Ref("inner"), Ref("props")));
}
else if (eventType is BeanEventType beanType) {
var superTypes = MakeSupertypes(beanType.SuperTypes, symbols.GetAddInitSvc(method));
var deepSuperTypes = MakeDeepSupertypes(beanType.DeepSuperTypesCollection, method, symbols, classScope);
method.Block
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleEventTypeInitServicesConstants.GETEVENTTYPECOLLECTOR)
.Add(
"RegisterBean",
Ref("metadata"),
Typeof(beanType.UnderlyingType),
Constant(beanType.StartTimestampPropertyName),
Constant(beanType.EndTimestampPropertyName),
superTypes,
deepSuperTypes));
}
else if (eventType is SchemaXMLEventType xmlType && (xmlType.RepresentsFragmentOfProperty != null)) {
method.Block
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleEventTypeInitServicesConstants.GETEVENTTYPECOLLECTOR)
.Add(
"RegisterXML",
Ref("metadata"),
Constant(xmlType.RepresentsFragmentOfProperty),
Constant(xmlType.RepresentsOriginalTypeName)));
}
public JsonEventBeanCopyMethodForge(JsonEventType eventType)
{
_eventType = eventType;
}
