Examples with LoopBranchElement org.iobserve.analysis.userbehavior.data.LoopBranchElement used on opensource projects

Example 1 with LoopBranchElement

use of org.iobserve.analysis.userbehavior.data.LoopBranchElement in project iobserve-analysis by research-iobserve.

the class PcmUsageModelBuilder method transformSequenceToScenarioBehavior.

/**
 * Creates a scenario behavior corresponding to the passed sequence. The sequence can be a
 * branch sequence or a loop sequence. It creates a sequence of entry level system calls
 * including loops within the sequence. It sets the successors and predecessors.
 *
 * @param indexOfScenario
 *            states the index of the created scenario within the usage scenario
 * @param sequence
 *            that is transformed to a scenario behavior
 * @param branch
 *            contains the child branches of the branch whose behavior is created
 * @return the created scenario behavior
 */
private // NOCS
ScenarioBehaviour transformSequenceToScenarioBehavior(// NOCS
final int indexOfScenario, final List<ISequenceElement> sequence, final Branch branch) {
    final ScenarioBehaviour scenarioBehaviour = UsageModelFactory.createScenarioBehaviour();
    final Start start = UsageModelFactory.createAddStartAction("", scenarioBehaviour);
    final Stop stop = UsageModelFactory.createAddStopAction("", scenarioBehaviour);
    EntryLevelSystemCall lastESysCall = UsageModelFactory.createEmptyEntryLevelSystemCall();
    boolean isLastElementACall = false;
    Loop lastLoop = UsageModelFactory.createEmptyLoop();
    boolean isLastElementALoop = false;
    org.palladiosimulator.pcm.usagemodel.Branch lastLoopBranch = UsagemodelFactory.eINSTANCE.createBranch();
    boolean isLastElementALoopBranch = false;
    org.palladiosimulator.pcm.usagemodel.Branch lastBranch = UsagemodelFactory.eINSTANCE.createBranch();
    boolean isLastElementABranch = false;
    /**
     * Loops over all elements of the sequence and creates a corresponding scenario behavior by
     * connecting the elements via successor and predecessor connections.
     */
    for (final ISequenceElement branchElement : sequence) {
        // Element is a entryLevelSystemCall
        if (branchElement.getClass().equals(CallElement.class)) {
            EntryLevelSystemCall eSysCall = null;
            // Workaround TODO
            final String operationSignature = branchElement.getOperationSignature().replaceAll("\\(.*\\)", "()");
            final String[] operationSplit = operationSignature.split(" ");
            final Optional<Correspondent> optionCorrespondent = this.correspondenceModel.getCorrespondent(branchElement.getClassSignature(), operationSplit[operationSplit.length - 1]);
            if (optionCorrespondent.isPresent()) {
                final Correspondent correspondent = optionCorrespondent.get();
                if (PcmUsageModelBuilder.LOGGER.isDebugEnabled()) {
                    PcmUsageModelBuilder.LOGGER.debug("Usage: Found Correspondent: {}", correspondent.getPcmEntityName() + " " + correspondent.getPcmOperationName());
                }
                eSysCall = UsageModelFactory.createEntryLevelSystemCall(this.repositoryLookupModel, correspondent);
            }
            if (eSysCall != null) {
                if (isLastElementACall) {
                    UsageModelFactory.connect(lastESysCall, eSysCall);
                } else if (isLastElementALoop) {
                    UsageModelFactory.connect(lastLoop, eSysCall);
                } else if (isLastElementALoopBranch) {
                    UsageModelFactory.connect(lastLoopBranch, eSysCall);
                } else if (isLastElementABranch) {
                    UsageModelFactory.connect(lastBranch, eSysCall);
                } else {
                    UsageModelFactory.connect(start, eSysCall);
                }
                UsageModelFactory.addUserAction(scenarioBehaviour, eSysCall);
                lastESysCall = eSysCall;
                isLastElementACall = true;
                isLastElementALoop = false;
                isLastElementALoopBranch = false;
                isLastElementABranch = false;
            }
        } else if (branchElement.getClass().equals(LoopElement.class)) {
            // Element is a loop
            final Loop loop = this.createLoop(scenarioBehaviour, (LoopElement) branchElement);
            if (isLastElementACall) {
                UsageModelFactory.connect(lastESysCall, loop);
            } else if (isLastElementALoop) {
                UsageModelFactory.connect(lastLoop, loop);
            } else if (isLastElementALoopBranch) {
                UsageModelFactory.connect(lastLoopBranch, loop);
            } else if (isLastElementABranch) {
                UsageModelFactory.connect(lastBranch, loop);
            } else {
                UsageModelFactory.connect(start, loop);
            }
            lastLoop = loop;
            isLastElementALoop = true;
            isLastElementACall = false;
            isLastElementALoopBranch = false;
            isLastElementABranch = false;
        } else if (branchElement.getClass().equals(LoopBranchElement.class)) {
            // Element is a
            // looped Branch
            final org.palladiosimulator.pcm.usagemodel.Branch loopBranch = this.createLoopBranch(scenarioBehaviour, (LoopBranchElement) branchElement);
            if (isLastElementACall) {
                UsageModelFactory.connect(lastESysCall, loopBranch);
            } else if (isLastElementALoop) {
                UsageModelFactory.connect(lastLoop, loopBranch);
            } else if (isLastElementALoopBranch) {
                UsageModelFactory.connect(lastLoopBranch, loopBranch);
            } else if (isLastElementABranch) {
                UsageModelFactory.connect(lastBranch, loopBranch);
            } else {
                UsageModelFactory.connect(start, loopBranch);
            }
            lastLoopBranch = loopBranch;
            isLastElementALoopBranch = true;
            isLastElementACall = false;
            isLastElementALoop = false;
            isLastElementABranch = false;
        } else if (branchElement.getClass().equals(BranchElement.class)) {
            // Element is a
            // Branch
            final org.palladiosimulator.pcm.usagemodel.Branch branchInter = this.createBranch(scenarioBehaviour, (BranchElement) branchElement);
            if (isLastElementACall) {
                UsageModelFactory.connect(lastESysCall, branchInter);
            } else if (isLastElementALoop) {
                UsageModelFactory.connect(lastLoop, branchInter);
            } else if (isLastElementALoopBranch) {
                UsageModelFactory.connect(lastLoopBranch, branchInter);
            } else if (isLastElementABranch) {
                UsageModelFactory.connect(lastBranch, branchInter);
            } else {
                UsageModelFactory.connect(start, branchInter);
            }
            lastBranch = branchInter;
            isLastElementABranch = true;
            isLastElementALoopBranch = false;
            isLastElementACall = false;
            isLastElementALoop = false;
        } else {
            break;
        }
    }
    // checks if the branch got child branches
    if (branch == null) {
        if (isLastElementACall) {
            UsageModelFactory.connect(lastESysCall, stop);
        } else if (isLastElementALoop) {
            UsageModelFactory.connect(lastLoop, stop);
        } else if (isLastElementALoopBranch) {
            UsageModelFactory.connect(lastLoopBranch, stop);
        } else if (isLastElementABranch) {
            UsageModelFactory.connect(lastBranch, stop);
        } else {
            UsageModelFactory.connect(start, stop);
        }
    } else {
        final org.palladiosimulator.pcm.usagemodel.Branch branchUM = this.createChildBranch(scenarioBehaviour, indexOfScenario, branch);
        if (branchUM != null) {
            if (isLastElementACall) {
                UsageModelFactory.connect(lastESysCall, branchUM);
                UsageModelFactory.connect(branchUM, stop);
            } else if (isLastElementALoop) {
                UsageModelFactory.connect(lastLoop, branchUM);
                UsageModelFactory.connect(branchUM, stop);
            } else if (isLastElementALoopBranch) {
                UsageModelFactory.connect(lastLoopBranch, branchUM);
                UsageModelFactory.connect(branchUM, stop);
            } else if (isLastElementABranch) {
                UsageModelFactory.connect(lastBranch, branchUM);
                UsageModelFactory.connect(branchUM, stop);
            } else {
                UsageModelFactory.connect(start, branchUM);
                UsageModelFactory.connect(branchUM, stop);
            }
        } else {
            if (isLastElementACall) {
                UsageModelFactory.connect(lastESysCall, stop);
            } else if (isLastElementALoop) {
                UsageModelFactory.connect(lastLoop, stop);
            } else if (isLastElementALoopBranch) {
                UsageModelFactory.connect(lastLoopBranch, stop);
            } else if (isLastElementABranch) {
                UsageModelFactory.connect(lastBranch, stop);
            } else {
                UsageModelFactory.connect(start, stop);
            }
        }
    }
    return scenarioBehaviour;
}