public void TestSort() { var setOne = new LinkedHashSet <string>(); setOne.Add("a"); setOne.Add("b_sub"); var setTwo = new LinkedHashSet <string>(); setOne.Add("b_super"); setOne.Add("y"); var configs = new Dictionary <string, ConfigurationCommonEventTypeWithSupertype>(); ConfigurationCommonEventTypeWithSupertype config = new ConfigurationCommonEventTypeWithSupertype(); config.SuperTypes = Collections.SingletonSet("b_super"); configs["b_sub"] = config; var result = EventTypeRepositoryUtil.GetCreationOrder(setOne, setTwo, configs); Assert.AreEqual("[\"a\", \"b_super\", \"y\", \"b_sub\"]", result.RenderAny()); }
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)); }