Ejemplo n.º 1
0
        internal static CodegenMethod MakeInitEventTypes(
            CodegenClassScope classScope,
            ModuleCompileTimeServices compileTimeServices)
        {
            var symbolsEventTypeInit = new ModuleEventTypeInitializeSymbol();
            var initializeEventTypesMethod = CodegenMethod
                .MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsEventTypeInit, classScope)
                .AddParam(
                    typeof(EPModuleEventTypeInitServices),
                    ModuleEventTypeInitializeSymbol.REF_INITSVC.Ref);
            foreach (var eventType in compileTimeServices.EventTypeCompileTimeRegistry.NewTypesAdded) {
                var addType = RegisterEventTypeCodegen(
                    eventType,
                    initializeEventTypesMethod,
                    classScope,
                    symbolsEventTypeInit);
                initializeEventTypesMethod.Block.Expression(LocalMethod(addType));
            }

            return initializeEventTypesMethod;
        }
Ejemplo n.º 2
0
        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)));
            }