CODEWITHSUNDEEP
java
Radek
Radek

Reputation: 11101

is there a equivalent of StringBuilder for boolean in java?

I want my custom functions to modify / toggle a boolean variable. Let's say that I have code like

if (OK2continue) { findANDclick(new String[]{"id", "menuButton"});}
if (OK2continue) { findANDclick(new String[]{"src", ".*homeicon_calendar.*"}); }   
if (OK2continue) { findANDclick(new String[]{"src", ".*cycle_templates.*"});

I want to make sure that the flow of execution stops once any of the findANDclick functions toggles the variable OK2continue

I managed my functions to modify a String variable using StringBuilder.

Can I do the same for boolean type of variable?

Upvotes: 2

Views: 2026

Answers (4)

Thomas
Thomas

Reputation: 88707

Well, the concept of StringBuilder is to create a mutable and extendable String wrapper (meaning the string can be extended via append and the like :) ). You'd still have to pass it as a parameter to the method in order to modify it (or use a static var - not recommended).

Since boolean can't be extended, the only similarity would be the parameter to be mutable. So you can use MutableBoolean as Gordon suggested, but you'd still have to pass it.

Another option would be to return a boolean from findANDclick(...) and use the boolean opperators like: findAndClick(...) || findAndClick(...) || findAndClick(...) which would only execute the next findAndClick(...) if the previous returned false.

Since that option is somewhat hard to maintain, especially since you might have side effects in findAndClick(...) as well as being quite static and hard to read if you have more calls in there, you might want to use a list of function objects:

class FindAndClickExecutor {
  public FindAndClickExecutor(String[] params) {...}
  public boolean findAndClick() {...}
}

List<FindAndClickExecutor> faces = ...; //initialize appropriately

for( FindAndClickExecutor face : faces ) {
  boolean ok2continue = face.findAndClick();
  if( !ok2continue  ) {
   break;
  }
}

Edit: since there seem to be other methods as well, you might use a more general list:

interface Executor {
  boolean execute();
}

class FindAndClickExecutor implements Executor {
   public boolean execute() {} // findAndClick code here, set parameters using constructor
}

class FindAndSelectOptionExecutor implements Executor {
  public boolean execute() {} // findAndSelectOption code here
}

List<Executor> testCase1Sequence = ...; //initialize test case 1
List<Executor> testCase2Sequence = ...; //initialize test case 2

for( Executor ex : testCase1Sequence ) {
  boolean ok2continue = ex.execute();
  if( !ok2continue) {
    break;
  }
}

This example could also be expanded on, e.g. by using a more complex return value containing the continue flag and maybe more data (use interface here as well).

Edit 2: you could also use some scripting to define and the builder pattern to generate the list of executors for each test case.

Upvotes: 1

alphazero
alphazero

Reputation: 27224

You need to clarify your reference to your usage of StringBuilder.

Assuming:

  1. You pass reference of the StringBuilder to your method. String is changed in method. If this the case, then see @Gordon Murray Dent's answer.

  2. Your boolean flag is visible in the method but is not passed. A simple Boolean will do.

package sof_6232851;

public class SideEffectingMethod {
    static Boolean flag = false;
    public static void main(String[] args) {

        flag = true;
        System.out.format ("flag is %b\n", flag);

        clickMe();
        System.out.format ("flag is %b\n", flag);
    }

    /** this method side-effects instance variable flag */
    public static void clickMe () {
        flag = !flag;
    }
}

[edit list item #2 to reply to OP comment]:

Note that #2 is not really recommended. You mention your desire for "readable" code. Side-effecting methods works against that goal. 

public class ReturnValuesForFunAndProfit {
    public static void main(String[] args) {
        presentUI();
    }
    public static void presentUI() {
        if(!clickMe("woof")) return;
        if(!clickMe("meow")) return;
        if(!clickMe("hello")) return;
    }
    public static boolean clickMe (String blah) {
            // your logic here; this ex. always returns true
        return true;
    }
}

Upvotes: 1

Tom Anderson
Tom Anderson

Reputation: 47183

Push this code into its own method, and use a return:

if (findANDclick(new String[]{"id", "menuButton"})) return;
if (findANDclick(new String[]{"src", ".*homeicon_calendar.*"})) return;
if (findANDclick(new String[]{"src", ".*cycle_templates.*"})) return;

Given that all your method calls are the same, you could also use a loop:

String[][] buttons = {
    {"id", "menuButton"},
    {"src", ".*homeicon_calendar.*"},
    {"src", ".*cycle_templates.*"},
};
for (String[] button: buttons) {
    if (findANDclick(button)) return;
}

You might or might not find that more readable.

Upvotes: 1

GordyD
GordyD

Reputation: 5103

I can't say it is equivalent. But using MutableBoolean offers you a mutable boolean wrapper, similar to the concept of StringBuilder a mutable sequence of characters. See this JavaDoc for details.

Upvotes: 5

Related Questions