• Home
• com.fluxtion
• compiler
• 9.7.9
• source code
• JavaSourceGenerator.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.fluxtion.compiler.generation.targets.JavaSourceGenerator Maven / Gradle / Ivy

/*
 * Copyright (c) 2019-2025 gregory higgins.
 * All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the Server Side Public License, version 1,
 * as published by MongoDB, Inc.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * Server Side Public License for more details.
 *
 * You should have received a copy of the Server Side Public License
 * along with this program.  If not, see
 * .
 */
package com.fluxtion.compiler.generation.targets;

import com.fluxtion.compiler.EventProcessorConfig;
import com.fluxtion.compiler.EventProcessorConfig.DISPATCH_STRATEGY;
import com.fluxtion.compiler.NodeDispatchTable;
import com.fluxtion.compiler.builder.filter.FilterDescription;
import com.fluxtion.compiler.generation.GenerationContext;
import com.fluxtion.compiler.generation.model.*;
import com.fluxtion.compiler.generation.util.ClassUtils;
import com.fluxtion.compiler.generation.util.NaturalOrderComparator;
import com.fluxtion.runtime.EventProcessorContext;
import com.fluxtion.runtime.annotations.ExportService;
import com.fluxtion.runtime.annotations.OnEventHandler;
import com.fluxtion.runtime.annotations.OnParentUpdate;
import com.fluxtion.runtime.annotations.builder.FluxtionIgnore;
import com.fluxtion.runtime.audit.Auditor;
import com.fluxtion.runtime.audit.EventLogManager;
import com.fluxtion.runtime.callback.ExportFunctionAuditEvent;
import com.fluxtion.runtime.event.Event;
import com.fluxtion.runtime.input.EventFeed;
import com.fluxtion.runtime.input.SubscriptionManager;
import com.fluxtion.runtime.node.ForkedTriggerTask;
import com.fluxtion.runtime.node.MutableEventProcessorContext;
import lombok.Getter;
import net.vidageek.mirror.dsl.Mirror;
import net.vidageek.mirror.list.dsl.MirrorList;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import static com.fluxtion.compiler.generation.targets.JavaGenHelper.mapPrimitiveToWrapper;
import static com.fluxtion.compiler.generation.targets.JavaGenHelper.mapWrapperToPrimitive;
import static org.apache.commons.lang3.StringEscapeUtils.escapeJava;

/**
 * @author Greg Higgins
 */
public class JavaSourceGenerator {

    private static final String s4 = "    ";
    private static final String s8 = "        ";
    private static final String s12 = "            ";
    private static final String s16 = "                ";
    private static final String s20 = "                    ";
    private static final String s24 = "                        ";
    /**
     * String representation of life-cycle callback methods for initialise,
     * sorted in call order, in a list.
     */
    @Getter
    private final ArrayList initialiseMethodList;
    /**
     * String representation of life-cycle callback methods for start,
     * sorted in call order, in a list.
     */
    private final ArrayList startMethodList;
    /**
     * String representation of life-cycle callback methods for startComplete,
     * sorted in call order, in a list.
     */
    private final ArrayList startCompleteMethodList;
    /**
     * String representation of life-cycle callback methods for initialise,
     * sorted in call order, in a list.
     */
    private final ArrayList stopMethodList;
    /**
     * String representation of life-cycle callback methods for end of batch,
     * sorted in call order.
     */
    @Getter
    private final ArrayList batchEndMethodList;
    /**
     * String representation of life-cycle callback methods for after event
     * processing, sorted in call order.
     */
    @Getter
    private final ArrayList eventEndMethodList;
    /**
     * String representation of life-cycle callback methods for batch pause,
     * sorted in call order.
     */
    @Getter
    private final ArrayList batchPauseMethodList;
    /**
     * String representation of life-cycle callback methods for tearDown, sorted
     * in call order.
     */
    @Getter
    private final ArrayList tearDownMethodList;
    /**
     * String representation of node declarations as a list.
     */
    @Getter
    private final ArrayList nodeDeclarationList;
    private final ArrayList importList;
    /**
     * String representation of the initial member assignments for each node
     */
    @Getter
    private final ArrayList nodeMemberAssignmentList;
    /**
     * String representation of public nodes as a list.
     */
    private final ArrayList publicNodeIdentifierList;
    private final SimpleEventProcessorModel model;
    /**
     * use reflection to assign private members
     */
    private final boolean assignPrivateMembers;
    private final StringBuilder nodeDecBuilder = new StringBuilder(5 * 1000 * 1000);
    private final HashMap importMap = new HashMap<>();
    private final StringBuilder ct = new StringBuilder(5 * 1000 * 1000);
    private final StringBuilder switchF = new StringBuilder(5 * 1000 * 1000);
    private final StringBuilder filteredMethodBuffer = new StringBuilder(5 * 1000 * 1000);
    /**
     * Create an if based dispatch using instanceof operator
     */
    private final boolean instanceOfDispatch;
    private final EventProcessorConfig eventProcessorConfig;
    /**
     * String representation of life-cycle callback methods for initialise,
     * sorted in call order.
     */
    @Getter
    private String initialiseMethods;
    /**
     * String representation of life-cycle callback methods for start,
     * sorted in call order.
     */
    @Getter
    private String startMethods;
    /**
     * String representation of life-cycle callback methods for startComplete,
     * sorted in call order.
     */
    @Getter
    private String startCompleteMethods;
    /**
     * String representation of life-cycle callback methods for initialise,
     * sorted in call order.
     */
    @Getter
    private String stopMethods;
    /**
     * String representation of life-cycle callback methods for end of batch,
     * sorted in call order.
     */
    @Getter
    private String batchEndMethods;
    /**
     * String representation of life-cycle callback methods for end of batch,
     * sorted in call order.
     */
    @Getter
    private String eventEndMethods;
    /**
     * String representation of life-cycle callback methods for batch pause,
     * sorted in call order.
     */
    @Getter
    private String batchPauseMethods;
    /**
     * String representation of life-cycle callback methods for tearDown, sorted
     * in call order.
     */
    @Getter
    private String tearDownMethods;
    /**
     * String representation of node declarations.
     */
    @Getter
    private String nodeDeclarations;
    /**
     * String representation of dirty flag.
     */
    @Getter
    private String dirtyFlagDeclarations;
    /**
     * String representation of looking up dirty flag by instance
     */
    @Getter
    private String dirtyFlagLookup;
    /**
     * String representation of updating dirty flag by instance
     */
    @Getter
    private String dirtyFlagUpdate;
    /**
     * String representation of all dirty flag reset to false.
     */
    @Getter
    private String resetDirtyFlags;
    /**
     *
     */
    @Getter
    private String guardCheckMethods;
    /**
     * String representation of filter constants declarations.
     */
    @Getter
    private String filterConstantDeclarations;
    /**
     * String representation of the initial member assignments for each node
     */
    @Getter
    private String nodeMemberAssignments;
    @Getter
    private String dispatchOnlyNodeMemberAssignments;
    /**
     * String representation of top level event dispatch, branches on event type
     * -- GETTER --
     * String representation of top level event dispatch
     *  public void onEvent(com.fluxtion.api.event.Event event) 
     * 

     * 
     * public void handleEvent([specific event] event)
     * {
     * [eventHandlers]
     * 

     * }
     * 
     *
     * @return top level event dispatch string
     */
    @Getter
    private String eventDispatch;
    /**
     * String representing the delegated event handling methods for a specific
     * event type, will include branching based on filterId.
     * -- GETTER --
     * String representation of java code handling subclass of
     * 

     * , with support for specific
     * dispatch based upon
     * 

     * filterID. If
     * inlining is false the following output will be produced:
     * 

     * 
     * public void handleEvent([specific event] event)
     * {
     * [eventHandlers]
     * 

     * }
     * 
     *
     * @return type specific event dispatch code
     */
    @Getter
    private String eventHandlers;
    /**
     * String representing filtered event handler methods
     */
    @Getter
    private String filterEventHandlers;
    /**
     * String representing exported events
     */
    @Getter
    private String exportedMethods;
    /**
     * determines whether separate delegate eventHandling methods are generated.
     */
    private boolean isInlineEventHandling;
    /**
     * String representing event audit dispatch
     */
    private String eventAuditDispatch;
    /**
     * String representing event audit dispatch
     */
    @Getter
    private String assignNodeField;
    /**
     * are any auditors registered for this SEP
     */
    private boolean auditingEvent;
    private boolean auditingInvocations;
    private String auditMethodString;
    private String additionalInterfaces;
    @Getter
    private String javaDocEventClassList;
    @Getter
    private String forkDeclarations;
    @Getter
    private String resetForkTasks;
    final Set> nonUserClass;
    private String forkedAssignments;
    private boolean bufferDispatch = false;

    public JavaSourceGenerator(
            SimpleEventProcessorModel model, EventProcessorConfig eventProcessorConfig) {
        this.isInlineEventHandling = eventProcessorConfig.isInlineEventHandling();
        this.assignPrivateMembers = eventProcessorConfig.isAssignPrivateMembers();
        this.instanceOfDispatch = eventProcessorConfig.getDispatchStrategy() == DISPATCH_STRATEGY.INSTANCE_OF;
        this.model = model;
        this.eventProcessorConfig = eventProcessorConfig;
        this.eventHandlers = "";
        initialiseMethodList = new ArrayList<>();
        startMethodList = new ArrayList<>();
        startCompleteMethodList = new ArrayList<>();
        stopMethodList = new ArrayList<>();
        batchEndMethodList = new ArrayList<>();
        batchPauseMethodList = new ArrayList<>();
        eventEndMethodList = new ArrayList<>();
        tearDownMethodList = new ArrayList<>();
        nodeDeclarationList = new ArrayList<>();
        nodeMemberAssignmentList = new ArrayList<>();
        publicNodeIdentifierList = new ArrayList<>();
        importList = new ArrayList<>();
        nonUserClass = new HashSet<>();
        nonUserClass.add(EventLogManager.class);
    }

    private static boolean hasIdField(Class e) {
        return false;
    }

    public void buildSourceModel() throws Exception {
        checkAuditInvocations();
        buildMethodSource(model.getInitialiseMethods(), initialiseMethodList);
        buildMethodSource(model.getStartMethods(), startMethodList);
        buildMethodSource(model.getStartCompleteMethods(), startCompleteMethodList);
        buildMethodSource(model.getStopMethods(), stopMethodList);
        buildMethodSource(model.getBatchPauseMethods(), batchPauseMethodList);
        buildForkAwareMethodSource(model.getEventEndMethods(), eventEndMethodList);
        buildMethodSource(model.getBatchEndMethods(), batchEndMethodList);
        buildMethodSource(model.getTearDownMethods(), tearDownMethodList);
        addDefaultImports();
        buildNodeDeclarations();
        buildDirtyFlags();
        buildForkDeclarations();
        buildFilterConstantDeclarations();
        buildMemberAssignments();
        buildNodeRegistrationListeners();
        buildNodeFieldAssigner();
        buildEventDispatch();

        initialiseMethods = "";
        boolean firstLine = true;
        for (String initialiseMethod : initialiseMethodList) {
            initialiseMethods += (firstLine ? "" : "\n") + initialiseMethod;
            firstLine = false;
        }

        startMethods = String.join("\n", startMethodList);
        startCompleteMethods = String.join("\n", startCompleteMethodList);
        stopMethods = String.join("\n", stopMethodList);

        batchPauseMethods = "";
        firstLine = true;
        for (String initialiseMethod : batchPauseMethodList) {
            batchPauseMethods += (firstLine ? "" : "\n") + initialiseMethod;
            firstLine = false;
        }

        batchEndMethods = "";
        firstLine = true;
        for (String initialiseMethod : batchEndMethodList) {
            batchEndMethods += (firstLine ? "" : "\n") + initialiseMethod;
            firstLine = false;
        }

        eventEndMethods = "";
        firstLine = true;
        for (String initialiseMethod : eventEndMethodList) {
            eventEndMethods += (firstLine ? "" : "\n") + initialiseMethod;
            firstLine = false;
        }

        tearDownMethods = "";
        for (String initialiseMethod : tearDownMethodList) {
            tearDownMethods += initialiseMethod + "\n";
        }
        tearDownMethods = StringUtils.chomp(tearDownMethods);

        nodeMemberAssignments = "";
        dispatchOnlyNodeMemberAssignments = "";
        final StringBuilder memberAssignments = new StringBuilder(200 * nodeMemberAssignmentList.size());
        firstLine = true;
        for (String initialiseMethod : nodeMemberAssignmentList) {
            memberAssignments.append(firstLine ? "    " : "\n    ").append(initialiseMethod);
            firstLine = false;
        }

        if (model.isDispatchOnlyVersion()) {
            dispatchOnlyNodeMemberAssignments = "    @Override\n" +
                    "   public final void assignMembers(Map memberMap) {\n" +
                    "        memberMap.forEach((k, v) -> setField(k, v));\n" +
                    "        " + forkedAssignments +
                    "        " + memberAssignments +
                    "        if(subscriptionManager != null){\n" +
                    "            subscriptionManager.setSubscribingEventProcessor(this);\n" +
                    "        }\n" +
                    "        if(context != null) {\n" +
                    "            context.setEventProcessorCallback(this);\n" +
                    "        }\n" +
                    "  }\n\n";

            dispatchOnlyNodeMemberAssignments += "    @Override\n" +
                    "   public final void assignMembers(Map memberMap, Map contextMap) {\n" +
                    "        memberMap.forEach((k, v) -> setField(k, v));\n" +
                    "        if(context != null) {\n" +
                    "            context.replaceMappings(contextMap);\n" +
                    "        }\n" +
                    "        " + forkedAssignments +
                    "        " + memberAssignments +
                    "        if(subscriptionManager != null){\n" +
                    "            subscriptionManager.setSubscribingEventProcessor(this);\n" +
                    "        }\n" +
                    "        if(context != null) {\n" +
                    "            context.setEventProcessorCallback(this);\n" +
                    "        }\n" +
                    "  }\n";
        } else {
            nodeMemberAssignments = memberAssignments.toString();
        }
    }

    private void checkAuditInvocations() {
        List listenerFields = model.getNodeRegistrationListenerFields();
        auditingInvocations = listenerFields.stream()
                .map(Field::getInstance)
                .filter(Auditor.class::isInstance)
                .map(Auditor.class::cast)
                .anyMatch(Auditor::auditInvocations);
    }

    private void buildForkDeclarations() {
        String forkWrapperClass = getClassTypeName(ForkedTriggerTask.class);
        forkDeclarations = "";
        forkedAssignments = "";
        if (model.getTriggerOnlyCallBacks().isEmpty()) {
            return;
        }
        if (model.isDispatchOnlyVersion()) {
            forkDeclarations = model.getTriggerOnlyCallBacks().stream()
                    .filter(CbMethodHandle::isForkExecution)
                    .map(c -> "private " + forkWrapperClass + " " + c.forkVariableName() + ";")
                    .collect(Collectors.joining("\n", "//Forked declarations\n", "\n"));
            forkedAssignments = model.getTriggerOnlyCallBacks().stream()
                    .filter(CbMethodHandle::isForkExecution)
                    .map(c -> c.forkVariableName()
                            + " = new " + forkWrapperClass + "(" + c.invokeLambdaString()
                            + ", \"" + c.variableName + "\" );")
                    .collect(Collectors.joining("\n", "\n//Forked assignment\n", "\n"));
        } else {
            forkDeclarations = model.getTriggerOnlyCallBacks().stream()
                    .filter(CbMethodHandle::isForkExecution)
                    .map(c -> "private final " + forkWrapperClass + " " + c.forkVariableName()
                            + " = new " + forkWrapperClass + "(" + c.invokeLambdaString()
                            + ", \"" + c.variableName + "\" );")
                    .collect(Collectors.joining("\n", "\n//Forked declarations\n", "\n"));
        }

        resetForkTasks = model.getTriggerOnlyCallBacks().stream()
                .filter(CbMethodHandle::isForkExecution)
                .map(c -> c.forkVariableName() + ".reinitialize();")
                .collect(Collectors.joining("\n"));
    }

    private void buildMethodSource(List methodList, List methodSourceList) {
        for (CbMethodHandle method : methodList) {
            final String methodString = String.format("%8s%s.%s();", "", method.variableName, method.method.getName());
            methodSourceList.add(methodString);
        }
    }

    private void buildForkAwareMethodSource(List methodList, List methodSourceList) {
        Set