Returns {@literal true} if the {@link ReactiveLibrary} is available.

@param reactiveLibrary must not be {@literal null}.
@return {@literal true} if the {@link ReactiveLibrary} is available.
331837
public static boolean isAvailable(ReactiveLibrary reactiveLibrary) {

        LettuceAssert.notNull(reactiveLibrary, "ReactiveLibrary must not be null!");

        switch (reactiveLibrary) {
            case PROJECT_REACTOR:
                return PROJECT_REACTOR_PRESENT;
            case RXJAVA1:
                return RXJAVA1_PRESENT;
            case RXJAVA2:
                return RXJAVA2_PRESENT;
        }

        throw new IllegalArgumentException(String.format("ReactiveLibrary %s not supported", reactiveLibrary));
    }
979634
public static boolean isGrailsResource(Resource r) {
        try {
            String file = r.getURL().getFile();
            return isGrailsPath(file) || file.endsWith("GrailsPlugin.groovy");
        }
        catch (IOException e) {
            return false;
        }
    }
910303
@Override
    public void onLibraryInfo(String libraryVersion) {
        this.libraryVersion = libraryVersion;
        onZWaveControllerInfo(libraryVersion, homeId, nodeId);
    }
168232
public boolean exists(ResourcePatternResolver resolver) {
		Assert.notNull(resolver, "Resolver must not be null");
		if (resolver.getResource(this.path).exists()) {
			return true;
		}
		try {
			return anyExists(resolver);
		}
		catch (IOException ex) {
			return false;
		}
	}
367002
private boolean isReactive(Type type) {
    if (!ParameterizedType.class.isAssignableFrom(type.getClass())) {
      return false;
    }
    ParameterizedType parameterizedType = (ParameterizedType) type;
    Type raw = parameterizedType.getRawType();
    return Arrays.asList(((Class) raw).getInterfaces())
        .contains(Publisher.class);
  }
749049
public static boolean isJBossRepositoryClassLoader(ClassLoader loader)
   {
      Class<?> clazz = loader.getClass();
      while (!clazz.getName().startsWith("java"))
      {
         if ("org.jboss.mx.loading.RepositoryClassLoader".equals(clazz.getName()))
            return true;
         clazz = clazz.getSuperclass();
      }

      return false;
   }
830367
public static boolean isSLF4jAvailable() {
        if (SLF4jAvailable == null) {
            try {
                Class.forName("org.slf4j.Logger");
                setSLF4jAvailable(true);
            } catch (ClassNotFoundException e) {
                setSLF4jAvailable(false);
            }
        }

        return SLF4jAvailable;
    }
1207955
public static boolean isAlreadyRegisteredIn(ObjectMapper mapper) {

		Assert.notNull(mapper, "ObjectMapper must not be null!");
		return LinkMixin.class.equals(mapper.findMixInClassFor(Link.class));
	}
1022621
@Nullable
  public boolean loadLibraries() {
    synchronized (mLock) {
      if (mLoadLibraries == false) {
        return mLibrariesLoaded;
      }
      try {
        if (mLibraryNames != null) {
          for (String name : mLibraryNames) {
            SoLoader.loadLibrary(name);
          }
        }
        initialNativeCheck();
        mLibrariesLoaded = true;
        mLibraryNames = null;
      } catch (UnsatisfiedLinkError error) {
        Log.e(TAG, "Failed to load native lib (initial check): ", error);
        mLinkError = error;
        mLibrariesLoaded = false;
      } catch (Throwable other) {
        Log.e(TAG, "Failed to load native lib (other error): ", other);
        mLinkError = new UnsatisfiedLinkError("Failed loading libraries");
        mLinkError.initCause(other);
        mLibrariesLoaded = false;
      }
      mLoadLibraries = false;
      return mLibrariesLoaded;
    }
  }
591984
@TargetApi(Build.VERSION_CODES.KITKAT)
    public static boolean hasConsumerIrFeature(PackageManager manager) {
        return manager.hasSystemFeature(PackageManager.FEATURE_CONSUMER_IR);
    }
367206
@Override
    public boolean isDurable()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isDurable");

        final boolean dur = (_isPubSub && dispatcherState.isDurable());

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isDurable", Boolean.valueOf(dur));

        return dur;
    }
653757
function isLibrary (node) {
  return nodeType(node, exactMatch(nodeTypes.CONTRACTDEFINITION)) && node.attributes.isLibrary === true
}
267762
Boolean isResource(String resource) {
		Boolean isResource = false;
		if (!utils.isIdentifier(resource)) {
			try {
				String clazz = getControllerClass(resource);
				if (clazz != null) {
					Class.forName(clazz);
					isResource = true;
				}
			} catch (ClassNotFoundException e) {
				// It isn't a resource because there isn't a controller for it
			}
		}
		return isResource;
	}
132421
public <R> ReactiveSeq<R> mergeMap(final Function<? super T, ? extends Publisher<? extends R>> mapper) {
        return mergeMap(256,mapper);
    }
397254
public static boolean isProjectSource(Resource r) {
        try {
            String file = r.getURL().getFile();
            return isProjectSource(file) || file.endsWith("GrailsPlugin.groovy");
        }
        catch (IOException e) {
            return false;
        }
    }
104345
public boolean isCompatible()
    {
    boolean compatible;
    Iterator<VarBindingDef> bindings;
    VarBindingDef binding = null;

    for( compatible = true,
           bindings = getBindings();

         compatible
           && bindings.hasNext();

         compatible =
           (binding = bindings.next())
           .getEffectiveCondition()
           .compatible( properties_));

    if( !compatible && size() == 1)
      {
      throw
        new IllegalStateException
        ( "Invalid " + binding
          + ", value condition=" + binding.getValueDef().getCondition()
          + " is incompatible its own properties=" + binding.getValueDef().getProperties());
      }
    
    return compatible;
    }
652405
public static BooleanBinding isInfinite(final ObservableDoubleValue observableValue) {
        return Bindings.createBooleanBinding(() -> Double.isInfinite(observableValue.get()), observableValue);
    }