public StmtClassForgeableJsonUnderlying(
string className,
string classNameFull,
CodegenNamespaceScope namespaceScope,
StmtClassForgeableJsonDesc desc)
{
this.className = className;
this.classNameFull = classNameFull;
this.namespaceScope = namespaceScope;
this.desc = desc;
}
private static void GenerateApplicationClassForgables(
Type optionalUnderlyingProvided,
IDictionary <Type, JsonApplicationClassSerializationDesc> deepClasses,
IList <StmtClassForgeableFactory> additionalForgeables,
Attribute[] annotations,
StatementCompileTimeServices services)
{
foreach (var entry in deepClasses)
{
if (entry.Key == optionalUnderlyingProvided)
{
continue;
}
var fields = new LinkedHashMap <string, FieldInfo>();
entry.Value.Fields.ForEach(field => fields.Put(field.Name, field));
var properties = ResolvePropertiesFromFields(fields);
var fieldNames = ComputeFieldNamesFromProperties(properties);
var forges = ComputeValueForges(properties, fields, deepClasses, annotations, services);
var fieldDescriptors = ComputeFields(properties, fieldNames, null, fields);
var forgeableDesc = new StmtClassForgeableJsonDesc(properties, fieldDescriptors, false, 0, null, forges);
var deserializerClassNameSimple = entry.Value.DeserializerClassName;
var deserializer = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonDeserializer(
CodegenClassType.JSONDESERIALIZER,
deserializerClassNameSimple,
namespaceScope,
entry.Key.FullName,
forgeableDesc),
};
var serializerClassNameSimple = entry.Value.SerializerClassName;
var serializer = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => new StmtClassForgeableJsonSerializer(
CodegenClassType.JSONSERIALIZER,
serializerClassNameSimple,
true,
namespaceScope,
entry.Key.FullName,
forgeableDesc),
};
additionalForgeables.Add(deserializer);
additionalForgeables.Add(serializer);
}
}
public static CodegenExpression[] GetCasesNumberNtoM(StmtClassForgeableJsonDesc desc)
{
var cases = new CodegenExpression[desc.PropertiesThisType.Count];
var index = 0;
foreach (var property in desc.PropertiesThisType) {
//var field = desc.FieldDescriptorsInclSupertype.Get(property.Key);
cases[index] = Constant(property.Key);
index++;
}
return cases;
}
public StmtClassForgeableJsonDeserializer(
CodegenClassType classType,
string className,
CodegenNamespaceScope namespaceScope,
string underlyingClassName,
StmtClassForgeableJsonDesc desc)
{
_classType = classType;
_className = className;
_namespaceScope = namespaceScope;
_underlyingClassName = underlyingClassName;
_desc = desc;
}
public StmtClassForgeableJsonSerializer(
CodegenClassType classType,
string className,
bool makeWriteMethod,
CodegenNamespaceScope namespaceScope,
string underlyingClassName,
StmtClassForgeableJsonDesc desc)
{
_classType = classType;
_className = className;
_makeWriteMethod = makeWriteMethod;
_namespaceScope = namespaceScope;
_underlyingClassName = underlyingClassName;
_desc = desc;
}
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));
}