Check if
<code>nValue &ge; nLowerBoundInclusive &amp;&amp; nValue &le; nUpperBoundInclusive</code>

@param aValue
Value
@param aName
Name
@param aLowerBoundInclusive
Lower bound
@param aUpperBoundInclusive
Upper bound
@return The value
338979
public static BigDecimal isBetweenInclusive (final BigDecimal aValue,
                                               @Nonnull final Supplier <? extends String> aName,
                                               @Nonnull final BigDecimal aLowerBoundInclusive,
                                               @Nonnull final BigDecimal aUpperBoundInclusive)
  {
    notNull (aValue, aName);
    notNull (aLowerBoundInclusive, "LowerBoundInclusive");
    notNull (aUpperBoundInclusive, "UpperBoundInclusive");
    if (isEnabled ())
      if (aValue.compareTo (aLowerBoundInclusive) < 0 || aValue.compareTo (aUpperBoundInclusive) > 0)
        throw new IllegalArgumentException ("The value of '" +
                                            aName.get () +
                                            "' must be >= " +
                                            aLowerBoundInclusive +
                                            " and <= " +
                                            aUpperBoundInclusive +
                                            "! The current value is: " +
                                            aValue);
    return aValue;
  }
55662
protected final void putInCache (@Nonnull final KEYTYPE aKey, @Nonnull final VALUETYPE aValue)
  {
    ValueEnforcer.notNull (aKey, "cacheKey");
    ValueEnforcer.notNull (aValue, "cacheValue");

    m_aRWLock.writeLocked ( () -> putInCacheNotLocked (aKey, aValue));
  }
967790
public static float isBetweenInclusive (final float fValue,
                                          @Nonnull final Supplier <? extends String> aName,
                                          final float fLowerBoundInclusive,
                                          final float fUpperBoundInclusive)
  {
    if (isEnabled ())
      if (fValue < fLowerBoundInclusive || fValue > fUpperBoundInclusive)
        throw new IllegalArgumentException ("The value of '" +
                                            aName.get () +
                                            "' must be >= " +
                                            fLowerBoundInclusive +
                                            " and <= " +
                                            fUpperBoundInclusive +
                                            "! The current value is: " +
                                            fValue);
    return fValue;
  }
79277
public VALUETYPE getFromCache (final KEYTYPE aKey)
  {
    VALUETYPE aValue = getFromCacheNoStats (aKey);
    if (aValue == null)
    {
      // No old value in the cache
      m_aRWLock.writeLock ().lock ();
      try
      {
        // Read again, in case the value was set between the two locking
        // sections
        // Note: do not increase statistics in this second try
        aValue = getFromCacheNoStatsNotLocked (aKey);
        if (aValue == null)
        {
          // Call the abstract method to create the value to cache
          aValue = m_aCacheValueProvider.apply (aKey);

          // Just a consistency check
          if (aValue == null)
            throw new IllegalStateException ("The value to cache was null for key '" + aKey + "'");

          // Put the new value into the cache
          putInCacheNotLocked (aKey, aValue);
          m_aCacheAccessStats.cacheMiss ();
        }
        else
          m_aCacheAccessStats.cacheHit ();
      }
      finally
      {
        m_aRWLock.writeLock ().unlock ();
      }
    }
    else
      m_aCacheAccessStats.cacheHit ();
    return aValue;
  }
226725
@Override
	public boolean isOverlapping(ConstantRange r) {
		if (!(r instanceof VarcharConstantRange))
			throw new IllegalArgumentException();
		if (!isValid() || !r.isValid())
			return false;
		VarcharConstantRange sr = (VarcharConstantRange) r;
		VarcharConstant rh = sr.high;
		boolean rhi = sr.highIncl;
		if (!low.equals(NEG_INF)
				&& ((lowIncl && ((rhi && rh.compareTo(low) < 0) || (!rhi && rh
						.compareTo(low) <= 0))) || (!lowIncl && rh
						.compareTo(low) <= 0)))
			return false;
		VarcharConstant rl = sr.low;
		boolean rli = sr.lowIncl;
		if (!high.equals(INF)
				&& ((highIncl && ((rli && rl.compareTo(high) > 0) || (!rli && rl
						.compareTo(high) >= 0))) || (!highIncl && rl
						.compareTo(high) >= 0)))
			return false;
		return true;
	}
288443
static final int guessLengthFromName(String aName) {
		
		if (aName.startsWith(Constants.PREFIX_SNAPSHOT_INTERVAL))
			return -1;
		
		int unitFactor;
		int value;
		
		try {
			value = Integer.parseInt(aName.substring(0, aName.length() - 1));
		} catch (NumberFormatException e) {
			throw new UnknownIntervalLengthException("Unsupported Interval name format: " + aName);
		}

		char lastChar = aName.charAt(aName.length() - 1);
		TimeUnit unit = lookupMap.get(Character.toLowerCase(lastChar));

		if (unit==null)
			throw new UnknownIntervalLengthException(aName + ", " + lastChar + " is not a supported unit.");
		
		unitFactor = unit.getFactor();

		if (value == 0)
			throw new UnknownIntervalLengthException(aName	+ ", zero duration is not allowed.");

		return value * unitFactor;
	}
1126513
@Pure
	public static String outsideRangeInclusiveParameter(int parameterIndex, Object currentValue,
			Object minValue, Object maxValue) {
		return msg("A6", parameterIndex, currentValue, minValue, maxValue); //$NON-NLS-1$
	}
829928
@Override
	public boolean isOverlapping(ConstantRange r) {
		if (!(r instanceof DoubleConstantRange))
			throw new IllegalArgumentException();
		if (!isValid() || !r.isValid())
			return false;
		DoubleConstantRange dr = (DoubleConstantRange) r;
		DoubleConstant rh = dr.high;
		boolean rhi = dr.highIncl;
		if (!low.equals(NEG_INF)
				&& ((lowIncl && ((rhi && rh.compareTo(low) < 0) || (!rhi && rh
						.compareTo(low) <= 0))) || (!lowIncl && rh
						.compareTo(low) <= 0)))
			return false;
		DoubleConstant rl = dr.low;
		boolean rli = dr.lowIncl;
		if (!high.equals(INF)
				&& ((highIncl && ((rli && rl.compareTo(high) > 0) || (!rli && rl
						.compareTo(high) >= 0))) || (!highIncl && rl
						.compareTo(high) >= 0)))
			return false;
		return true;
	}
1181542
static Binding from(Module namespaceBoundModule, Node sourceNode) {
    return new AutoValue_Binding(
        namespaceBoundModule.metadata(),
        sourceNode,
        /* originatingExport= */ null,
        /* isModuleNamespace= */ true,
        namespaceBoundModule.closureNamespace(),
        CreatedBy.IMPORT);
  }
604834
private boolean fallbackToNavtitleOrHref(final Element elem) {
        final String hrefValue = elem.getAttribute(ATTRIBUTE_NAME_HREF);
        final String locktitleValue = elem.getAttribute(ATTRIBUTE_NAME_LOCKTITLE);
        return ((ATTRIBUTE_NAME_LOCKTITLE_VALUE_YES.equals(locktitleValue)) ||
                ("".equals(hrefValue)) ||
                !(isLocalDita(elem)));
    }
1112526
public static AllowableValues emptyToNull(AllowableValues newValue, AllowableValues current) {
    if (newValue != null) {
      if (newValue instanceof AllowableListValues) {
        return defaultIfAbsent(emptyListValuesToNull((AllowableListValues) newValue), current);
      } else {
        return defaultIfAbsent(newValue, current);
      }
    }
    return current;
  }
466697
def _is_bounded_iterator_based(self):
        

        # Condition 0
        check_0 = lambda cond: (isinstance(cond, Condition) and
                                cond.op == Condition.Equal and
                                cond.val1 == 0 and
                                isinstance(cond.val0, AnnotatedVariable) and
                                cond.val0.type == VariableTypes.HasNext
                                )

        check_0_results = [ (check_0(stmt[0]), stmt[0]) for stmt in self.loop_exit_stmts ]
        check_0_conds = [ cond for r, cond in check_0_results if r ]  # remove all False ones

        if not check_0_conds:
            return None

        the_iterator = check_0_conds[0].val0.variable

        # Condition 1
        check_1 = lambda local: (isinstance(local, AnnotatedVariable) and
                                 local.type == VariableTypes.Next and
                                 local.variable == the_iterator
                                 )

        if not any([ check_1(local) for local in self.locals.values() ]):
            return None

        return True
1079981
@Nonnull
  public static <DATATYPE> SuccessWithValue <DATATYPE> createSuccess (@Nullable final DATATYPE aValue)
  {
    return new SuccessWithValue <> (ESuccess.SUCCESS, aValue);
  }
1208084
public double repairSolutionVariableValue(double value, double lowerBound, double upperBound) {
    if (lowerBound > upperBound) {
      throw new JMetalException("The lower bound (" + lowerBound + ") is greater than the "
          + "upper bound (" + upperBound+")") ;
    }

    double result = value ;
    if (value < lowerBound) {
      result = lowerBound ;
    }
    if (value > upperBound) {
      result = upperBound ;
    }

    return result ;
  }
1326957
@Override
  public final boolean isValid(final Object pvalue, final ConstraintValidatorContext pcontext) {
    final String valueAsString = Objects.toString(pvalue, null);
    if (StringUtils.isEmpty(valueAsString)) {
      return true;
    }
    if (!StringUtils.isNumeric(valueAsString)) {
      // EAN must be numeric, but that's handled by digits annotation
      return true;
    }
    if (valueAsString.length() != Gtin8Validator.GTIN8_LENGTH
        && valueAsString.length() != Gtin13Validator.GTIN13_LENGTH) {
      // EAN size is wrong, but that's handled by alternate size annotation
      return true;
    }
    // calculate and check checksum (GTIN/EAN)
    return CHECK_GTIN.isValid(valueAsString);
  }
402612
void reportBoundError(UndetVar uv, InferenceBound ib) {
        reportInferenceError(
                String.format("incompatible.%s.bounds", StringUtils.toLowerCase(ib.name())),
                uv.qtype,
                uv.getBounds(ib));
    }
1028121
private @CheckForNull NullnessAnnotation toNullnessAnnotation(@CheckForNull TypeQualifierAnnotation tqa) {
        if (tqa == null || tqa == TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION) {
            return null;
        }
        if (tqa.when == null) {
            new NullPointerException("TGA value with null when field").printStackTrace();
            return null;
        }



        switch (tqa.when) {
        case ALWAYS:
            return NullnessAnnotation.NONNULL;
        case MAYBE:
            return NullnessAnnotation.CHECK_FOR_NULL;
        case NEVER:
            return NullnessAnnotation.CHECK_FOR_NULL;
        case UNKNOWN:
            return NullnessAnnotation.UNKNOWN_NULLNESS;
        }

        throw new IllegalStateException();
    }