Example usage for org.eclipse.jdt.core.dom Block statements

List of usage examples for org.eclipse.jdt.core.dom Block statements

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom Block statements.

Prototype

ASTNode.NodeList statements

To view the source code for org.eclipse.jdt.core.dom Block statements.

Click Source Link

Document

The list of statements (element type: Statement ).

Usage

From source file:ac.at.tuwien.dsg.uml.statemachine.export.transformation.engines.impl.PathWithUncertaintyTestStrategy.java

License:Open Source License

/**
 * /*w w w. j a v a2s  .co  m*/
 * @param state - the state for which we inspect the transitions and generate the test plan
 * @param rewrite - rewriter used to modify the generated code
 * @param planMethodDeclaration - the method in which the code must be added
 * @param parrentPlanBlock - the block of code where the new state code must be added. Can be a method body, the body of an If statement, etc
 * @param pathTransitions - used to avoid testing cycles and ensure test plan keeps uniqueness on transitions
 */
private void generatePlanForState(final StateMachineState state, final ASTRewrite rewrite,
        final MethodDeclaration planMethodDeclaration, final Set<StateMachineStateTransition> pathTransitions) {

    AST ast = planMethodDeclaration.getAST();
    Block parrentPlanBlock = planMethodDeclaration.getBody();

    ListRewrite listRewrite = rewrite.getListRewrite(parrentPlanBlock, Block.STATEMENTS_PROPERTY);

    /**
     * First we create an abstract method to assert that we have reached current state and we call it
     * only if the state is not a choice. Choices are "virtual" states that signal splits in transition.
     * 
     */
    {

        //only create method if not previously created
        String stateName = state.getName();
        String methodName = ASSERT_STATE_LEADING + stateName;
        if (!generatedAbstractMethods.containsKey(stateName)) {
            MethodDeclaration method = createAbstractMethodForState(state, planMethodDeclaration.getAST());
            generatedAbstractMethods.put(stateName, method);
        }

        /**
         * Call the assert state method to check if we have reached the current state.
         * For the initial state this assert can also reset the system to initial state.
         */
        {
            //invoke guard as Assert statement
            AssertStatement assertStatement = ast.newAssertStatement();
            MethodInvocation invocation = ast.newMethodInvocation();
            invocation.setName(ast.newSimpleName(methodName));
            assertStatement.setExpression(invocation);

            parrentPlanBlock.statements().add(assertStatement);

            //                  listRewrite.insertFirst(rewrite.createStringPlaceholder("//Call the assert state method to check if we have reached the current state.", ASTNode.EMPTY_STATEMENT), null);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("//For the initial state this assert can also reset the system to initial state.", ASTNode.EMPTY_STATEMENT), null);
            //                  listRewrite.insertLast(assertStatement, null);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
        }

    }

    /**
     * If from one state we have multiple triggers, or from a choice we can go to multiple classes
     * then we generate for each of these transitions paths a separate test plan.
     * This means we clone the previous method into how many we need
     */
    List<StateMachineStateTransition> transitions = state.getOutTransitions();

    //if 1 transition, then we add to same plan
    //if more, we need separate test plans for each branching
    if (transitions.isEmpty() && !(state.getVertex() instanceof FinalState)) {
        //notify user that  something is wrong with the model we are converting 
        notifyUser("State \"" + state.getName()
                + "\"is not final and does not have any transitions. All state machine flows must reach a FinalState.");
        System.err.println(state.getName()
                + " is not final and does not have any transitions. All state machine flows must reach a FinalState to be converted in test plans.");
    } else if (transitions.size() == 1) {
        StateMachineStateTransition transition = transitions.get(0);

        //if we have visited this transition, continue
        if (pathTransitions.contains(transition)) {
            return;
        } else {
            // add transition to visited transitions
            pathTransitions.add(transition);
        }

        //                listRewrite.insertLast(rewrite.createStringPlaceholder("//Test transition " + transition.getTransition().getName(), ASTNode.EMPTY_STATEMENT), null);

        /**
         * Must assert before any transition that the guard condition is fulfilled
         */
        {
            //get transition condition (could also be Rule, currently we get only Guard transitions)
            Constraint guard = transition.getTransition().getGuard();
            if (guard != null) {
                for (Element element : guard.allOwnedElements()) {
                    //currently condition retrieved as plain text that will need to be parsed and evaluated
                    OpaqueExpression expression = (OpaqueExpression) element;
                    for (String body : expression.getBodies()) {
                        if (body.isEmpty()) {
                            notifyUser("Guard condition for transition  " + transition.getTransition().getName()
                                    + " from state " + state.getName() + " is empty");
                            System.err.println(
                                    "Guard condition for transition  " + transition.getTransition().getName()
                                            + " from state " + state.getName() + " is empty");
                            continue;
                        }
                        MethodDeclaration method = createAbstractMethodForGuard(body, ast);
                        if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                            generatedAbstractMethods.put(method.getName().toString(), method);
                        }
                        //invoke guard as Assert statement
                        AssertStatement assertStatement = ast.newAssertStatement();
                        MethodInvocation invocation = ast.newMethodInvocation();
                        invocation.setName(ast.newSimpleName(method.getName().toString()));
                        assertStatement.setExpression(invocation);

                        parrentPlanBlock.statements().add(assertStatement);

                        //                           listRewrite.insertLast(rewrite.createStringPlaceholder("//Assert guard condition for next transition is true", ASTNode.EMPTY_STATEMENT), null);
                        //                           listRewrite.insertLast(assertStatement, null);
                        //                           listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                    }
                }
            }
        }

        //get all transition triggers
        List<Trigger> triggers = transition.getTransition().getTriggers();

        //for each trigger
        for (Trigger trigger : triggers) {

            /**
             * If we have not created it already, we create an abstract method to invoke the trigger
             */
            {
                //TODO: update so we do not generate the trigger if it was already generated
                MethodDeclaration method = createAbstractTriggerInvocation(trigger,
                        planMethodDeclaration.getAST());
                if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                    generatedAbstractMethods.put(method.getName().toString(), method);
                }
                //invoke trigger
                MethodInvocation invocation = ast.newMethodInvocation();
                invocation.setName(ast.newSimpleName(method.getName().toString()));
                //                     listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke transition trigger", ASTNode.EMPTY_STATEMENT), null);
                //                     listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                //                     listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);

                parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));

            }

        }

        if (!(state.getVertex() instanceof FinalState)) {
            //continue from target state with plan generation

            StateMachineState targetState = transition.getTargetState();
            generatePlanForState(targetState, rewrite, planMethodDeclaration, pathTransitions);
        } else {
            if (transition.getTargetState() == null) {
                notifyUser(state.getName() + " is not final and does not have a target state on transition "
                        + transition.getTransition().getName());
                System.err.println(
                        state.getName() + " is not final and does not have a target state on transition "
                                + transition.getTransition().getName());
            }
        }

    } else if (transitions.size() > 1) {
        for (StateMachineStateTransition transition : transitions) {

            //clone transitions to use clean path for each sub-trees
            Set<StateMachineStateTransition> transitionsCopy = new HashSet<>();
            transitionsCopy.addAll(pathTransitions);

            //if we have visited this transition, continue
            if (transitionsCopy.contains(transition)) {
                continue;
            } else {
                // add transition to visited transitions
                transitionsCopy.add(transition);
            }

            //for each transition we do a clone of the plan until now
            MethodDeclaration transitionMethod = cloneMethodDeclaration(planMethodDeclaration);
            transitionMethod.setName(ast
                    .newSimpleName(PLAN_METHOD_LEADING + (UUID.randomUUID().toString().replaceAll("\\W", ""))));

            //shadowing to local parrentPlanBlock
            parrentPlanBlock = transitionMethod.getBody();

            //shadowing to local ListRewrite 
            //                  listRewrite = rewrite.getListRewrite(transitionMethod.getBody(), Block.STATEMENTS_PROPERTY);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("//Forcing transition " + transition.getTransition().getName() + " by ensuring guard conditions are met and triggers are invoked.", ASTNode.EMPTY_STATEMENT), null);
            /**
             * Must force-set all guard conditions to navigate to this particular execution branch
             */
            {
                //get transition condition (could also be Rule, currently we get only Guard transitions)
                //force for the current test the transition condition to true, to enable the system to navigate to expected state
                Constraint guard = transition.getTransition().getGuard();
                if (guard != null) {
                    for (Element element : guard.allOwnedElements()) {
                        //currently condition retrieved as plain text that will need to be parsed and evaluated
                        OpaqueExpression expression = (OpaqueExpression) element;
                        for (String body : expression.getBodies()) {

                            if (body.isEmpty()) {
                                notifyUser("Guard condition for transition  "
                                        + transition.getTransition().getName() + " from state "
                                        + state.getName() + " is empty");
                                System.err.println("Guard condition for transition  "
                                        + transition.getTransition().getName() + " from state "
                                        + state.getName() + " is empty");
                                continue;
                            }

                            MethodDeclaration method = createAbstractForceConditionMethod(body, ast);
                            if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                                generatedAbstractMethods.put(method.getName().toString(), method);
                            }
                            //invoke method to force guard condition to true
                            MethodInvocation invocation = ast.newMethodInvocation();
                            invocation.setName(ast.newSimpleName(method.getName().toString()));
                            //                              listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke method to force guard condition to true: " + body, ASTNode.EMPTY_STATEMENT), null);
                            //                              listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                            //                              listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                            parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));
                        }
                    }
                }
            }

            //get all transition triggers and execute them, like if we had only one transition
            List<Trigger> triggers = transition.getTransition().getTriggers();

            //for each trigger
            for (Trigger trigger : triggers) {

                /**
                 * If we have not created it already, we create an abstract method to invoke the trigger
                 */
                {
                    //TODO: update so we do not generate the trigger if it was already generated
                    MethodDeclaration method = createAbstractTriggerInvocation(trigger,
                            transitionMethod.getAST());
                    if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                        generatedAbstractMethods.put(method.getName().toString(), method);
                    }
                    //invoke trigger
                    MethodInvocation invocation = ast.newMethodInvocation();
                    invocation.setName(ast.newSimpleName(method.getName().toString()));
                    //                        listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke transition trigger", ASTNode.EMPTY_STATEMENT), null);
                    //                        listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                    //                        listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                    parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));
                }

            }

            if (!(state.getVertex() instanceof FinalState)) {
                //continue from target state with plan generation
                StateMachineState targetState = transition.getTargetState();
                generatePlanForState(targetState, rewrite, transitionMethod, transitionsCopy);
            } else {
                if (transition.getTargetState() == null) {
                    notifyUser(state.getName() + " is not final and does not have a target state on transition "
                            + transition.getTransition().getName());
                    System.err.println(
                            state.getName() + " is not final and does not have a target state on transition "
                                    + transition.getTransition().getName());
                }
            }

        }

    }

    if (state.getVertex() instanceof FinalState) {
        //store generated method in methods
        //check and store only if there is at least one transition with an uncertain state 
        boolean hasUncertainty = false;
        for (StateMachineStateTransition transition : pathTransitions) {

            //TODO: remove constant and make this efficient

            //check for all transitions only initial state for uncertainties
            //as for next transition, the initial will be the target of this one (except for final state)
            for (Stereotype stereotype : transition.getSourceState().getVertex().getAppliedStereotypes()) {
                //check if the applied stereotype is InfrastructureLevelUncertainty
                if (stereotype.getName().equals(INFRASTRUCTURE_UNCERTAINTY_NAME)) {
                    hasUncertainty = true;
                    break;
                }
            }
        }

        //if does not have any uncertainty on it, do not add it to generated plans
        if (hasUncertainty) {
            generatedPlans.put(planMethodDeclaration.getName().toString(), planMethodDeclaration);
        }
    }

}

From source file:ac.at.tuwien.dsg.uml.statemachine.export.transformation.engines.impl.TransitionCorrectnessTestStrategy.java

License:Open Source License

/**
 * //from  w  w w . jav a 2s . c  o  m
 * @param state - the state for which we inspect the transitions and generate the test plan
 * @param rewrite - rewriter used to modify the generated code
 * @param planMethodDeclaration - the method in which the code must be added
 * @param parrentPlanBlock - the block of code where the new state code must be added. Can be a method body, the body of an If statement, etc
 * @param pathTransitions - used to avoid testing cycles and ensure test plan keeps uniqueness on transitions
 */
private void generatePlanForState(final StateMachineState state, final ASTRewrite rewrite,
        final MethodDeclaration planMethodDeclaration, final Set<StateMachineStateTransition> pathTransitions) {

    AST ast = planMethodDeclaration.getAST();
    Block parrentPlanBlock = planMethodDeclaration.getBody();

    ListRewrite listRewrite = rewrite.getListRewrite(parrentPlanBlock, Block.STATEMENTS_PROPERTY);

    /**
     * First we create an abstract method to assert that we have reached current state and we call it
     * only if the state is not a choice. Choices are "virtual" states that signal splits in transition.
     * 
     */
    {

        //only create method if not previously created
        String stateName = state.getName();
        String methodName = ASSERT_STATE_LEADING + stateName;
        if (!generatedAbstractMethods.containsKey(stateName)) {
            MethodDeclaration method = createAbstractMethodForState(state, planMethodDeclaration.getAST());
            generatedAbstractMethods.put(stateName, method);
        }

        /**
        * Call the assert state method to check if we have reached the current state.
        * For the initial state this assert can also reset the system to initial state.
        */
        {
            //invoke guard as Assert statement
            AssertStatement assertStatement = ast.newAssertStatement();
            MethodInvocation invocation = ast.newMethodInvocation();
            invocation.setName(ast.newSimpleName(methodName));
            assertStatement.setExpression(invocation);

            parrentPlanBlock.statements().add(assertStatement);

            //                  listRewrite.insertFirst(rewrite.createStringPlaceholder("//Call the assert state method to check if we have reached the current state.", ASTNode.EMPTY_STATEMENT), null);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("//For the initial state this assert can also reset the system to initial state.", ASTNode.EMPTY_STATEMENT), null);
            //                  listRewrite.insertLast(assertStatement, null);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
        }

    }

    /**
     * If from one state we have multiple triggers, or from a choice we can go to multiple classes
     * then we generate for each of these transitions paths a separate test plan.
     * This means we clone the previous method into how many we need
     */
    List<StateMachineStateTransition> transitions = state.getOutTransitions();

    //if 1 transition, then we add to same plan
    //if more, we need separate test plans for each branching
    if (transitions.isEmpty() && !(state.getVertex() instanceof FinalState)) {
        //notify user that  something is wrong with the model we are converting 
        notifyUser("State \"" + state.getName()
                + "\"is not final and does not have any transitions. All state machine flows must reach a FinalState.");
        System.err.println(state.getName()
                + " is not final and does not have any transitions. All state machine flows must reach a FinalState to be converted in test plans.");
    } else if (transitions.size() == 1) {
        StateMachineStateTransition transition = transitions.get(0);

        //if we have visited this transition, continue
        if (pathTransitions.contains(transition)) {
            return;
        } else {
            // add transition to visited transitions
            pathTransitions.add(transition);
        }

        //                listRewrite.insertLast(rewrite.createStringPlaceholder("//Test transition " + transition.getTransition().getName(), ASTNode.EMPTY_STATEMENT), null);

        /**
        * Must assert before any transition that the guard condition is fulfilled
        */
        {
            //get transition condition (could also be Rule, currently we get only Guard transitions)
            Constraint guard = transition.getTransition().getGuard();
            if (guard != null) {
                for (Element element : guard.allOwnedElements()) {
                    //currently condition retrieved as plain text that will need to be parsed and evaluated
                    OpaqueExpression expression = (OpaqueExpression) element;
                    for (String body : expression.getBodies()) {
                        if (body.isEmpty()) {
                            notifyUser("Guard condition for transition  " + transition.getTransition().getName()
                                    + " from state " + state.getName() + " is empty");
                            System.err.println(
                                    "Guard condition for transition  " + transition.getTransition().getName()
                                            + " from state " + state.getName() + " is empty");
                            continue;
                        }
                        MethodDeclaration method = createAbstractMethodForGuard(body, ast);
                        if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                            generatedAbstractMethods.put(method.getName().toString(), method);
                        }
                        //invoke guard as Assert statement
                        AssertStatement assertStatement = ast.newAssertStatement();
                        MethodInvocation invocation = ast.newMethodInvocation();
                        invocation.setName(ast.newSimpleName(method.getName().toString()));
                        assertStatement.setExpression(invocation);

                        parrentPlanBlock.statements().add(assertStatement);

                        //                           listRewrite.insertLast(rewrite.createStringPlaceholder("//Assert guard condition for next transition is true", ASTNode.EMPTY_STATEMENT), null);
                        //                           listRewrite.insertLast(assertStatement, null);
                        //                           listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                    }
                }
            }
        }

        //get all transition triggers
        List<Trigger> triggers = transition.getTransition().getTriggers();

        //for each trigger
        for (Trigger trigger : triggers) {

            /**
             * If we have not created it already, we create an abstract method to invoke the trigger
             */
            {
                //TODO: update so we do not generate the trigger if it was already generated
                MethodDeclaration method = createAbstractTriggerInvocation(trigger,
                        planMethodDeclaration.getAST());
                if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                    generatedAbstractMethods.put(method.getName().toString(), method);
                }
                //invoke trigger
                MethodInvocation invocation = ast.newMethodInvocation();
                invocation.setName(ast.newSimpleName(method.getName().toString()));
                //                     listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke transition trigger", ASTNode.EMPTY_STATEMENT), null);
                //                     listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                //                     listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);

                parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));

            }

        }

        if (!(state.getVertex() instanceof FinalState)) {
            //continue from target state with plan generation
            StateMachineState targetState = transition.getTargetState();
            generatePlanForState(targetState, rewrite, planMethodDeclaration, pathTransitions);
        } else {
            if (transition.getTargetState() == null) {
                notifyUser(state.getName() + " is not final and does not have a target state on transition "
                        + transition.getTransition().getName());
                System.err.println(
                        state.getName() + " is not final and does not have a target state on transition "
                                + transition.getTransition().getName());
            }
        }

    } else if (transitions.size() > 1) {

        for (StateMachineStateTransition transition : transitions) {

            //clone transitions to use clean path for each sub-trees
            //cloning is done here as we are generating different paths for each transition at this point
            Set<StateMachineStateTransition> transitionsCopy = new HashSet<>();
            transitionsCopy.addAll(pathTransitions);

            //if we have visited this transition, continue
            if (transitionsCopy.contains(transition)) {
                continue;
            } else {
                // add transition to visited transitions
                transitionsCopy.add(transition);
            }

            //for each transition we do a clone of the plan until now
            MethodDeclaration transitionMethod = cloneMethodDeclaration(planMethodDeclaration);
            transitionMethod.setName(ast
                    .newSimpleName(PLAN_METHOD_LEADING + (UUID.randomUUID().toString().replaceAll("\\W", ""))));

            //shadowing to local parrentPlanBlock
            parrentPlanBlock = transitionMethod.getBody();

            //shadowing to local ListRewrite 
            //                  listRewrite = rewrite.getListRewrite(transitionMethod.getBody(), Block.STATEMENTS_PROPERTY);
            //                  listRewrite.insertLast(rewrite.createStringPlaceholder("//Forcing transition " + transition.getTransition().getName() + " by ensuring guard conditions are met and triggers are invoked.", ASTNode.EMPTY_STATEMENT), null);
            /**
             * Must force-set all guard conditions to navigate to this particular execution branch
             */
            {
                //get transition condition (could also be Rule, currently we get only Guard transitions)
                //force for the current test the transition condition to true, to enable the system to navigate to expected state
                Constraint guard = transition.getTransition().getGuard();
                if (guard != null) {
                    for (Element element : guard.allOwnedElements()) {
                        //currently condition retrieved as plain text that will need to be parsed and evaluated
                        OpaqueExpression expression = (OpaqueExpression) element;
                        for (String body : expression.getBodies()) {

                            if (body.isEmpty()) {
                                notifyUser("Guard condition for transition  "
                                        + transition.getTransition().getName() + " from state "
                                        + state.getName() + " is empty");
                                System.err.println("Guard condition for transition  "
                                        + transition.getTransition().getName() + " from state "
                                        + state.getName() + " is empty");
                                continue;
                            }

                            MethodDeclaration method = createAbstractForceConditionMethod(body, ast);
                            if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                                generatedAbstractMethods.put(method.getName().toString(), method);
                            }
                            //invoke method to force guard condition to true
                            MethodInvocation invocation = ast.newMethodInvocation();
                            invocation.setName(ast.newSimpleName(method.getName().toString()));
                            //                              listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke method to force guard condition to true: " + body, ASTNode.EMPTY_STATEMENT), null);
                            //                              listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                            //                              listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                            parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));
                        }
                    }
                }
            }

            //get all transition triggers and execute them, like if we had only one transition
            List<Trigger> triggers = transition.getTransition().getTriggers();

            //for each trigger
            for (Trigger trigger : triggers) {

                /**
                 * If we have not created it already, we create an abstract method to invoke the trigger
                 */
                {
                    //TODO: update so we do not generate the trigger if it was already generated
                    MethodDeclaration method = createAbstractTriggerInvocation(trigger,
                            transitionMethod.getAST());
                    if (!generatedAbstractMethods.containsKey(method.getName().toString())) {
                        generatedAbstractMethods.put(method.getName().toString(), method);
                    }
                    //invoke trigger
                    MethodInvocation invocation = ast.newMethodInvocation();
                    invocation.setName(ast.newSimpleName(method.getName().toString()));
                    //                        listRewrite.insertLast(rewrite.createStringPlaceholder("//Invoke transition trigger", ASTNode.EMPTY_STATEMENT), null);
                    //                        listRewrite.insertLast(ast.newExpressionStatement(invocation), null);
                    //                        listRewrite.insertLast(rewrite.createStringPlaceholder("", ASTNode.EMPTY_STATEMENT), null);
                    parrentPlanBlock.statements().add(ast.newExpressionStatement(invocation));
                }

            }

            if (!(state.getVertex() instanceof FinalState)) {
                //continue from target state with plan generation
                StateMachineState targetState = transition.getTargetState();
                generatePlanForState(targetState, rewrite, transitionMethod, transitionsCopy);
            } else {
                if (transition.getTargetState() == null) {
                    notifyUser(state.getName() + " is not final and does not have a target state on transition "
                            + transition.getTransition().getName());
                    System.err.println(
                            state.getName() + " is not final and does not have a target state on transition "
                                    + transition.getTransition().getName());
                }
            }

        }

    }

    if (state.getVertex() instanceof FinalState) {
        //store generated method in methods
        generatedPlans.put(planMethodDeclaration.getName().toString(), planMethodDeclaration);
    }

}

From source file:at.bestsolution.fxide.jdt.corext.dom.ASTFlattener.java

License:Open Source License

@Override
public boolean visit(Block node) {
    this.fBuffer.append("{");//$NON-NLS-1$
    for (Iterator<Statement> it = node.statements().iterator(); it.hasNext();) {
        Statement s = it.next();//www . j  a  v  a  2s .c  om
        s.accept(this);
    }
    this.fBuffer.append("}");//$NON-NLS-1$
    return false;
}

From source file:boa.datagen.util.Java7Visitor.java

License:Apache License

@Override
public boolean visit(Block node) {
    boa.types.Ast.Statement.Builder b = boa.types.Ast.Statement.newBuilder();
    //      b.setPosition(pos.build());
    List<boa.types.Ast.Statement> list = statements.peek();
    b.setKind(boa.types.Ast.Statement.StatementKind.BLOCK);
    for (Object s : node.statements()) {
        statements.push(new ArrayList<boa.types.Ast.Statement>());
        ((org.eclipse.jdt.core.dom.Statement) s).accept(this);
        for (boa.types.Ast.Statement st : statements.pop())
            b.addStatements(st);//w w w  .  j  a v  a  2 s.c om
    }
    list.add(b.build());
    return false;
}

From source file:br.com.objectos.way.core.code.jdt.ASTTest.java

License:Apache License

@SuppressWarnings("unchecked")
public void stackoverflow_answer() {
    AST ast = AST.newAST(AST.JLS8);//  ww  w  . jav a2s.  c  om
    CompilationUnit cu = ast.newCompilationUnit();

    PackageDeclaration p1 = ast.newPackageDeclaration();
    p1.setName(ast.newSimpleName("foo"));
    cu.setPackage(p1);

    ImportDeclaration id = ast.newImportDeclaration();
    id.setName(ast.newName(new String[] { "java", "util", "Set" }));
    cu.imports().add(id);

    TypeDeclaration td = ast.newTypeDeclaration();
    td.setName(ast.newSimpleName("Foo"));
    TypeParameter tp = ast.newTypeParameter();
    tp.setName(ast.newSimpleName("X"));
    td.typeParameters().add(tp);
    cu.types().add(td);

    MethodDeclaration md = ast.newMethodDeclaration();
    md.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    md.setName(ast.newSimpleName("bar"));

    SingleVariableDeclaration var = ast.newSingleVariableDeclaration();
    var.setType(ast.newSimpleType(ast.newSimpleName("String")));
    var.setName(ast.newSimpleName("a"));
    md.parameters().add(var);
    td.bodyDeclarations().add(md);

    Block block = ast.newBlock();
    md.setBody(block);

    MethodInvocation mi = ast.newMethodInvocation();
    mi.setName(ast.newSimpleName("x"));

    ExpressionStatement e = ast.newExpressionStatement(mi);
    block.statements().add(e);

    System.out.println(cu);
}

From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java

License:Apache License

private static void merge(CompilationUnit unit, String pkgName, String typeName, String auth, String dbName,
        List<String> tableCreators) {
    unit.recordModifications();//from ww w  .jav  a2  s. co m
    AST ast = unit.getAST();
    TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
    ImportDeclaration id = ast.newImportDeclaration();
    id.setName(ast.newName("cn.ieclipse.aorm.Session"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.content.UriMatcher"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.database.sqlite.SQLiteDatabase"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.database.sqlite.SQLiteOpenHelper"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("java.net.Uri"));
    unit.imports().add(id);

    id = ast.newImportDeclaration();
    id.setName(ast.newName("android.content.ContentValue"));
    unit.imports().add(id);

    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("AUTH"));
    StringLiteral sl = ast.newStringLiteral();
    sl.setLiteralValue(auth);
    vdf.setInitializer(sl);

    FieldDeclaration fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL)));
    fd.setType(ast.newSimpleType(ast.newSimpleName("String")));

    int i = 0;
    type.bodyDeclarations().add(i++, fd);

    // URI = Uri.parse("content://" + AUTH);
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("URI"));

    MethodInvocation mi = ast.newMethodInvocation();
    mi.setExpression(ast.newSimpleName("Uri"));
    mi.setName(ast.newSimpleName("parse"));

    InfixExpression fix = ast.newInfixExpression();
    fix.setOperator(InfixExpression.Operator.PLUS);
    sl = ast.newStringLiteral();
    sl.setLiteralValue("content://");
    fix.setLeftOperand(sl);
    fix.setRightOperand(ast.newSimpleName("AUTH"));

    mi.arguments().add(fix);

    vdf.setInitializer(mi);
    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL)));
    fd.setType(ast.newSimpleType(ast.newSimpleName("Uri")));

    type.bodyDeclarations().add(i++, fd);

    // private mOpenHelper;
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("mOpenHelper"));

    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
    fd.setType(ast.newSimpleType(ast.newName("SQLiteOpenHelper")));
    type.bodyDeclarations().add(i++, fd);

    // private static session;
    vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("session"));

    fd = ast.newFieldDeclaration(vdf);
    fd.modifiers().addAll(ast.newModifiers((Modifier.PRIVATE | Modifier.STATIC)));
    fd.setType(ast.newSimpleType(ast.newName("Session")));
    type.bodyDeclarations().add(i++, fd);

    // public static Session getSession(){
    // return session;
    // }

    MethodDeclaration md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC | Modifier.STATIC)));
    md.setReturnType2(ast.newSimpleType(ast.newName("Session")));
    md.setName(ast.newSimpleName("getSession"));

    Block methodBlock = ast.newBlock();
    ReturnStatement returnStmt = ast.newReturnStatement();
    returnStmt.setExpression(ast.newSimpleName("session"));
    methodBlock.statements().add(returnStmt);
    md.setBody(methodBlock);
    type.bodyDeclarations().add(i, md);

    // modify onCreate
    rewriteOnCreate(unit, dbName, tableCreators);
}

From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java

License:Apache License

private static void rewriteOnCreate(CompilationUnit unit, String dbName, List<String> tableCreators) {
    AST ast = unit.getAST();//from   ww w  . j  a  v a  2  s  . c  o  m
    TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
    MethodDeclaration onCreate = getMethod(type, ("onCreate"), null);
    if (onCreate != null) {
        Block methodBlock = ast.newBlock();

        // mOpenHelper = new
        // InlineOpenHelper(this.getContext(),"person.db",null,1);
        Assignment a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("mOpenHelper"));

        ClassInstanceCreation cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("SQLiteOpenHelper")));
        ThisExpression thisExp = ast.newThisExpression();
        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("getContext"));
        mi.setExpression(thisExp);
        cc.arguments().add(mi);
        StringLiteral sl = ast.newStringLiteral();
        sl.setLiteralValue(dbName);

        cc.arguments().add(sl);
        cc.arguments().add(ast.newNullLiteral());
        cc.arguments().add(ast.newNumberLiteral("1"));
        a.setRightHandSide(cc);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        AnonymousClassDeclaration acd = ast.newAnonymousClassDeclaration();
        cc.setAnonymousClassDeclaration(acd);
        genInnerSQLiteOpenHelper(acd, ast, tableCreators);

        a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("session"));

        ClassInstanceCreation cic = ast.newClassInstanceCreation();
        cic.setType(ast.newSimpleType(ast.newSimpleName("Session")));

        // SingleVariableDeclaration svd =
        // ast.newSingleVariableDeclaration();
        // svd.setName(ast.newSimpleName("mOpenHelper"));
        cic.arguments().add(ast.newSimpleName("mOpenHelper"));
        // vdf.setInitializer(cic);
        a.setRightHandSide(cic);
        // methodBlock.statements().add(vde);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        ReturnStatement returnStmt = ast.newReturnStatement();
        returnStmt.setExpression(ast.newBooleanLiteral(true));
        methodBlock.statements().add(returnStmt);

        onCreate.setBody(methodBlock);
    }
}

From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java

License:Apache License

private static void genInnerSQLiteOpenHelper(AnonymousClassDeclaration acd, AST ast,
        List<String> tableCreators) {
    MethodDeclaration md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC)));
    md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    md.setName(ast.newSimpleName("onCreate"));
    SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("db"));
    svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase")));
    md.parameters().add(svd);// w ww . jav  a 2s  . c  om
    Block innerBlock = ast.newBlock();
    md.setBody(innerBlock);
    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("sql"));
    StringLiteral sl = ast.newStringLiteral();
    sl.setLiteralValue("");
    vdf.setInitializer(sl);
    VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf);
    vds.setType(ast.newSimpleType(ast.newSimpleName("String")));
    innerBlock.statements().add(vds);
    for (String creator : tableCreators) {
        String[] lines = creator.split(SourceAnalysis.LF);
        for (String line : lines) {
            Assignment a = ast.newAssignment();
            a.setOperator(Assignment.Operator.PLUS_ASSIGN);
            a.setLeftHandSide(ast.newSimpleName("sql"));
            StringLiteral temp = ast.newStringLiteral();
            temp.setLiteralValue(line);
            a.setRightHandSide(temp);
            innerBlock.statements().add(ast.newExpressionStatement(a));
        }

        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("execSQL"));
        mi.setExpression(ast.newSimpleName("db"));
        mi.arguments().add(ast.newSimpleName("sql"));
        innerBlock.statements().add(ast.newExpressionStatement(mi));
    }

    acd.bodyDeclarations().add(md);
    // onUpgrade
    md = ast.newMethodDeclaration();
    md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC)));
    md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    md.setName(ast.newSimpleName("onUpgrade"));
    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("db"));
    svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase")));
    md.parameters().add(svd);

    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("oldVersion"));
    svd.setType(ast.newPrimitiveType(PrimitiveType.INT));
    md.parameters().add(svd);

    svd = ast.newSingleVariableDeclaration();
    svd.setName(ast.newSimpleName("newVersion"));
    svd.setType(ast.newPrimitiveType(PrimitiveType.INT));
    md.parameters().add(svd);

    innerBlock = ast.newBlock();
    md.setBody(innerBlock);
    acd.bodyDeclarations().add(md);
}

From source file:coloredide.utils.CopiedNaiveASTFlattener.java

License:Open Source License

public boolean visit(Block node) {
    this.buffer.append("{\n");//$NON-NLS-1$
    this.indent++;
    for (Iterator it = node.statements().iterator(); it.hasNext();) {
        Statement s = (Statement) it.next();
        s.accept(this);
    }//from  ww w .j a v a2 s.com
    this.indent--;
    printIndent();
    this.buffer.append("}\n");//$NON-NLS-1$
    return false;
}

From source file:com.architexa.diagrams.relo.jdt.ParseUtilities.java

License:Open Source License

/**
 * @param method/*from   w  ww  . j  a  v  a  2s.c  o m*/
 * @return SourceRange
 * @throws JavaModelException
 */
public static ISourceRange getBodyRange(IMethod method) throws JavaModelException {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(method.getCompilationUnit());
    CompilationUnit cu = (CompilationUnit) parser.createAST(null);
    TypeDeclaration td = findTypeDeclaration(cu, method);
    MethodDeclaration md = findMethodDeclaration(td, method);
    Block body = md.getBody();
    final int startPos;
    final int length;
    List<?> bodyStatements = body.statements();
    int stmnts = bodyStatements.size();
    if (stmnts > 0) {
        startPos = ((Statement) bodyStatements.get(0)).getStartPosition();
        Statement lastStmnt = (Statement) bodyStatements.get(stmnts - 1);
        length = lastStmnt.getStartPosition() + lastStmnt.getLength() - startPos;
    } else {
        startPos = body.getStartPosition();
        length = body.getLength();
    }
    return new ISourceRange() {
        public int getLength() {
            return length;
        }

        public int getOffset() {
            return startPos;
        }
    };
}