If set to true, initial prompt is not interruptible by either voice or digits.
<p>
<b>Defaults to false.</b> Valid values are the text strings "true" and "false".
</p>

@return
967922
public boolean getNonInterruptibleAudio() {
        String value = Optional.fromNullable(getParameter(SignalParameters.NON_INTERRUPTIBLE_PLAY.symbol())).or("false");
        return Boolean.parseBoolean(value);
    }
1146130
protected boolean trivialClause() {
        boolean res = false;
        final LNGIntVector newAddedLits = new LNGIntVector(this.addedlits.size());
        for (int i = 0; i < this.addedlits.size(); i++) {
            final int lit = this.addedlits.get(i);
            assert lit != 0;
            final int m = marked(lit);
            if (m < 0) {
                res = true;
                break;
            } else if (m == 0) {
                newAddedLits.push(lit);
                mark(lit);
            }
        }
        this.addedlits = newAddedLits;
        unmark();
        return res;
    }
557856
public String getEnabledValueString() {
        String valueEnabledString = this.getProperty("value");
        if (valueEnabledString == null) {
            valueEnabledString = DEFAULT_ENABLED_VALUE;
        }

        return valueEnabledString;
    }
367571
public boolean isValid()
    {
    // Must be non-empty...
    boolean valid = varNamePath_ != null;

    if( valid)
      {
      // Containing a sequence of identifiers...
      int i;
      for( i = 0; i < varNamePath_.length && DefUtils.isIdentifier( varNamePath_[i]); i++);

      // Optionally terminated by a single wildcard.
      int membersLeft = varNamePath_.length - i;
      valid =
        membersLeft == 0
        ||
        (membersLeft == 1
         &&
         (varNamePath_[i].equals( ALL_DESCENDANTS) || varNamePath_[i].equals( ALL_CHILDREN)));
      }

    return valid;
    }
345644
@Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        //may contain multiple values, semicolon separated.
        if (!StringUtils.isBlank(value)) {
            String[] values = value.split(";");
            for (String val : values) {
                try {
                    new IpAddressMatcher(val);
                } catch (IllegalArgumentException ex) {
                    return false;
                }
            }
            return true;
        } else {
            return true;
        }
    }
871748
private boolean validateParameters() {

        boolean allOk = true;

        StringBuffer validationErrors = new StringBuffer(32);
        CmsMessages messages = Messages.get().getBundle(getLocale());

        // check resource parameter presence
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamResource()) || !getCms().existsResource(getParamResource())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_VFS_RESOURCE_0)).append("<br>");
        }

        // check selected property name
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamPropertyName())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_SELECT_PROPERTY_0)).append("<br>");
        }

        // check old property value to look up
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamOldValue())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_OLD_PROP_VALUE_0)).append("<br>");
        } else {
            try {
                // check if there is a place holder in the expression pattern
                // remove it here, because otherwise this is no valid expression pattern
                String oldValue = getParamOldValue();
                if (oldValue.contains(CmsStringUtil.PLACEHOLDER_START)
                    && oldValue.contains(CmsStringUtil.PLACEHOLDER_END)) {
                    oldValue = oldValue.replace(CmsStringUtil.PLACEHOLDER_START, "");
                    oldValue = oldValue.replace(CmsStringUtil.PLACEHOLDER_END, "");
                }
                // compile regular expression pattern
                Pattern.compile(oldValue);
            } catch (PatternSyntaxException e) {
                allOk = false;
                validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_OLD_PROP_PATTERN_0)).append(
                    "<br>");
            }
        }

        // check new property value
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamNewValue())) {
            // if no new value was given, set it to the delete value
            setParamNewValue(CmsProperty.DELETE_VALUE);
        }

        setErrorMessage(validationErrors.toString());
        setValidationErrors(!allOk);
        return allOk;
    }
480724
public boolean isSentenceStart() {
    return posToken != null && JLanguageTool.SENTENCE_START_TAGNAME.equals(posToken.posTag) && !posToken.negation;
  }
495759
private static Boolean stringToBoolean(String value) {
		final String s = blankToNull(value);
		return s == null ? null : Boolean.valueOf(s);
	}
1198007
private boolean isTruthy(String value) {
    return value != null &&
           value.trim().toLowerCase().startsWith(TRUTHY_INITIAL_CHARACTER);
  }
401556
public int truePositives() {
    int tp = 0;
    for(int i = 0; i < confusion.length; i++) {
      tp += truePositives(i);
    }
    return tp;
  }
474008
public static Boolean readBoolean(String value, Boolean defaultValue) {
		if (!StringUtils.hasText(value)) return defaultValue;
		
		return Boolean.valueOf(value);
	}
447053
public boolean isActive() {
		final long now = System.currentTimeMillis();
		final long start = values.getStart();
		final long end = start + values.getLeft();
		// TODO : Ensure predicate consistency.
		return now >= start && now <= end;
	}
844289
public boolean validate()
  {
    boolean correct = true;
    if (population() > 1)
    {
      java.util.Comparator comp = index().insertComparator();
      int xcc = 0;
      for (int i = 0; i < population()-1; i++)
      {
        xcc = comp.compare(_nodeKey[i], _nodeKey[i+1]);
        if ( !(xcc < 0) )
          {
            System.out.println("Entry " + i + " not less than entry " + i+1);
            correct = false;
          }
      }
    }
    return correct;
  }
167543
public static boolean areValid(String... strings) {
		boolean result = false;
		if(strings != null) {
			result = true;
			for(String string : strings) {
				result = result && isValid(string);
			}
		}
		return result;
	}
373799
public boolean valid()
    {
        boolean valid = true;
        if (tc.isEntryEnabled())
            Tr.entry(tc, "valid", this);
        if (_status == STATUS_INVALID)
            valid = false;
        if (tc.isEntryEnabled())
            Tr.exit(tc, "valid", new Boolean(valid));
        return valid;
    }
674857
public Boolean getAsBoolean() {
		if (value instanceof String) {
			return Boolean.parseBoolean((String)value);
		}
		return (Boolean)value;
	}
434738
public boolean isChecked() {
        String valueEnabledString = getEnabledValueString();

        String currentValue = this.getFirstValue();
        return valueEnabledString.equals(currentValue);
    }