Returns {@literal true} if {@code type} is a reactive wrapper type that contains no value.

@param type must not be {@literal null}.
@return {@literal true} if {@code type} is a reactive wrapper type that contains no value.
766188
public static boolean isNoValueType(Class<?> type) {

        LettuceAssert.notNull(type, "Class must not be null!");

        return findDescriptor(type).map(Descriptor::isNoValue).orElse(false);
    }
115431
public static boolean isCollectionType(final Type type) {
        return isParameterizedType(type) && isCollectionType((Class<?>) ((ParameterizedType) type).getRawType());
    }
1192952
public boolean isKindOf(final Type _type)
    {
        boolean ret = false;
        Type type = this;
        while (type != null && type.getId() != _type.getId()) {
            type = type.getParentType();
        }
        if (type != null && type.getId() == _type.getId()) {
            ret = true;
        }
        return ret;
    }
680899
public static boolean isJavaConstantType(TypeMirror type)
    {
        switch (type.getKind())
        {
            case INT:
            case LONG:
            case FLOAT:
            case DOUBLE:
                return true;
            case DECLARED:
                DeclaredType dt = (DeclaredType) type;
                TypeElement te = (TypeElement) dt.asElement();
                return "java.lang.String".contentEquals(te.getQualifiedName());
            default:
                return false;
        }
    }
252966
static boolean isIThenableSubtype(JSType type) {
    if (type.isTemplatizedType()) {
      TemplatizedType ttype = type.toMaybeTemplatizedType();
      return ttype.getTemplateTypeMap().hasTemplateKey(ttype.registry.getThenableValueKey());
    }
    return false;
  }
1337540
public static boolean isInner(final Type type) {
        if (type instanceof ParameterizedType) {
            return ((ParameterizedType) type).getOwnerType() != null;
        }
        final Class<?> actual = GenericsUtils.resolveClassIgnoringVariables(type);
        // interface is always static and can't use outer generics
        return !actual.isInterface() && actual.isMemberClass() && !Modifier.isStatic(actual.getModifiers());
    }
1182616
public static boolean checkValueIsType(Object value, Object name, Class type) {
        if (value != null) {
            if (type.isAssignableFrom(value.getClass())) {
                return true;
            } else {
                throw new RuntimeException("The value argument of '" + name + "' must be of type "
                        + type.getName() + ". Found: " + value.getClass());
            }
        } else {
            return false;
        }
    }
221242
public boolean isSubtypeOf(JvmType type) {
		if (type == null) {
			throw new IllegalArgumentException("type may not be null");
		}
		// TODO interfaces don't inherit from non-interfaces, primitives, arrays, object
		// A final type does not have any subtypes
		// check for type == this.type
		LightweightTypeReference other = owner.toPlainTypeReference(type);
		boolean result = other.isAssignableFrom(this);
		return result;
	}
645996
public static boolean isEligibleType(Class<?> type) {
		return type.isAnnotationPresent(Type.class) &&
				!ReflectionUtils.getAnnotatedFields(type, Id.class, true).isEmpty();
	}
593856
public static boolean isPopulatable(final Type type) {
        return !isWildcardType(type) && !isTypeVariable(type) && !isCollectionType(type) && !isParameterizedType(type);
    }
122918
public static boolean isInteger(TypeMirror type)
    {
        switch (type.getKind())
        {
            case INT:
            case SHORT:
            case CHAR:
            case BYTE:
            case BOOLEAN:
                return true;
            default:
                return false;
        }
    }
444120
public static boolean isPropertyType(final Class type) {
        return type != null && (isPrimitiveLike(type) || type == DBRef.class || type == Pattern.class
                                || type == CodeWScope.class || type == ObjectId.class || type == Key.class
                                || type == DBObject.class || type == BasicDBObject.class);

    }
668243
private static boolean containsTypeVariables(final Type type) {
        if (type instanceof TypeVariable<?>) {
            return true;
        }
        if (type instanceof Class<?>) {
            return ((Class<?>) type).getTypeParameters().length > 0;
        }
        if (type instanceof ParameterizedType) {
            for (final Type arg : ((ParameterizedType) type).getActualTypeArguments()) {
                if (containsTypeVariables(arg)) {
                    return true;
                }
            }
            return false;
        }
        if (type instanceof WildcardType) {
            final WildcardType wild = (WildcardType) type;
            return containsTypeVariables(TypeUtils.getImplicitLowerBounds(wild)[0])
                    || containsTypeVariables(TypeUtils.getImplicitUpperBounds(wild)[0]);
        }
        return false;
    }
1217249
public static boolean isPrimitive(Type type) {
        return type.equals(boolean.class)
                || type.equals(double.class)
                || type.equals(float.class)
                || type.equals(short.class)
                || type.equals(int.class)
                || type.equals(long.class)
                || type.equals(byte.class)
                || type.equals(char.class);
    }
155443
public boolean containsOfType(final Class<? extends Tag> type) {
	read.lock();
	try {
	    return tags.containsKey(type);
	} finally {
	    read.unlock();
	}
    }
1224294
public static boolean isWrapper(Class<?> type) {

        if (Boolean.class == type) {
            return true;
        } 
        if (Byte.class == type) {
            return true;
        } 
        if (Character.class == type) {
            return true;
        } 
        if (Short.class == type) {
            return true;
        } 
        if (Integer.class == type) {
            return true;
        } 
        if (Long.class == type) {
            return true;
        }
        if (Float.class == type) {
            return true;
        } 
        if (Double.class == type) {
            return true;
        }
        return false;
    }
446086
public static boolean isNumberObj(Object type) {
        try {
            Double.valueOf(type + "");
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }