Returns true if this type is not primitive, but it has a primitive
type peer.
14826
public boolean hasPrimitivePeer() {
        if (mObjectClass == Integer.class ||
            mObjectClass == Boolean.class ||
            mObjectClass == Byte.class ||
            mObjectClass == Character.class ||
            mObjectClass == Short.class ||
            mObjectClass == Long.class ||
            mObjectClass == Float.class ||
            mObjectClass == Double.class ||
            mObjectClass == Void.class) {

            return true;
        }

        return false;
    }
289115
public static boolean isPrimitiveArray(Class<?> type) {
        logger.entering(type);
        checkArgument(type != null, "Type cannot be null.");
        logger.exiting(PRIMITIVE_ARRAY_TYPES.contains(type));
        return PRIMITIVE_ARRAY_TYPES.contains(type);
    }
535358
def is_subtype (type, base):
    
    assert isinstance(type, basestring)
    assert isinstance(base, basestring)
    # TODO: remove this method
    return is_derived (type, base)
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;
	}
361268
function isPrimitive(type) {
	return (type === String || type === Number || type === Boolean || type === Symbol);
}
1066574
private boolean isCompatibleType(Object value, Class<?> type) {
        // Do object check first, then primitives
        if (value == null || type.isInstance(value)) {
            return true;

        } else if (type.equals(Integer.TYPE) && Integer.class.isInstance(value)) {
            return true;

        } else if (type.equals(Long.TYPE) && Long.class.isInstance(value)) {
            return true;

        } else if (type.equals(Double.TYPE) && Double.class.isInstance(value)) {
            return true;

        } else if (type.equals(Float.TYPE) && Float.class.isInstance(value)) {
            return true;

        } else if (type.equals(Short.TYPE) && Short.class.isInstance(value)) {
            return true;

        } else if (type.equals(Byte.TYPE) && Byte.class.isInstance(value)) {
            return true;

        } else if (type.equals(Character.TYPE) && Character.class.isInstance(value)) {
            return true;

        } else if (type.equals(Boolean.TYPE) && Boolean.class.isInstance(value)) {
            return true;

        } else if (BigDecimal.class.isInstance(value)) {
            return true;

        } else if (BigInteger.class.isInstance(value)) {
            return true;
        }
        return false;

    }
628068
Class<?> classOfPrimitiveFor(String primitiveType) {
        return ClassUtils.getPrimitiveType(primitiveType).orElseThrow(() -> new IllegalArgumentException("Unknown primitive type: " + primitiveType));
    }
105565
protected boolean hasAllCanonicalTypes() {
        if (types.length==0) return false;
        for (String typeName : types) {
            InternalRelationType type = QueryUtil.getType(tx, typeName);
            if (type!=null && !type.isPropertyKey() && !type.multiplicity().isUnique(dir)) return false;
        }
        return true;
    }
1326503
def is_type(type_, *p):
    
    try:
        for i in p:
            if i.type_ != type_:
                return False

        return True
    except:
        pass

    return False
1144515
boolean contains(ProtoMember protoMember) {
    if (protoMember == null) throw new NullPointerException("protoMember == null");
    if (identifierSet.excludes(protoMember)) return false;
    return members.containsKey(protoMember.type())
        ? members.containsEntry(protoMember.type(), protoMember)
        : types.contains(protoMember.type());
  }
896087
protected boolean isPrimitiveBoolean(JvmTypeReference typeRef) {
		if (InferredTypeIndicator.isInferred(typeRef)) {
			return false;
		}
		
		return typeRef != null && typeRef.getType() != null &&
				!typeRef.getType().eIsProxy() &&
				"boolean".equals(typeRef.getType().getIdentifier());
	}
887794
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$11;

  return value === proto;
}
1166663
public static boolean isSubtype(final Class<? extends Entity> descendant, final Class<? extends Entity> ancestor) {
	return !ancestor.equals(descendant) && ancestor.isAssignableFrom(descendant);
    }
664463
private boolean compareTypesOld(Type parmType, Type argType) {
        // XXX equality not implemented for GenericObjectType
        // if (parmType.equals(argType)) return true;
        // Compare type signatures instead
        if (GenericUtilities.getString(parmType).equals(GenericUtilities.getString(argType))) {
            return true;
        }

        if (parmType instanceof GenericObjectType) {
            GenericObjectType o = (GenericObjectType) parmType;
            if (o.getTypeCategory() == GenericUtilities.TypeCategory.WILDCARD_EXTENDS) {
                return compareTypesOld(o.getExtension(), argType);
            }
        }
        // ignore type variables for now
        if (parmType instanceof GenericObjectType && !((GenericObjectType) parmType).hasParameters()) {
            return true;
        }
        if (argType instanceof GenericObjectType && !((GenericObjectType) argType).hasParameters()) {
            return true;
        }

        // Case: Both are generic containers
        if (parmType instanceof GenericObjectType && argType instanceof GenericObjectType) {
            return true;
        } else {
            // Don't consider non reference types (should not be possible)
            if (!(parmType instanceof ReferenceType && argType instanceof ReferenceType)) {
                return true;
            }

            // Don't consider non object types (for now)
            if (!(parmType instanceof ObjectType && argType instanceof ObjectType)) {
                return true;
            }

            // Otherwise, compare base types ignoring generic information
            try {
                return Repository.instanceOf(((ObjectType) argType).getClassName(), ((ObjectType) parmType).getClassName());
            } catch (ClassNotFoundException e) {
            }
        }

        return true;
    }
1370067
public Type toPrimitive() {
        if (mPrimitive) {
            return this;
        }
        else {
            Class<?> primitive = convertToPrimitive(mObjectClass);
            if (primitive.isPrimitive()) { return new Type(primitive); }
            else { return new Type(mGenericType, primitive); }
        }
    }
821176
public boolean isType(final org.efaps.admin.datamodel.Type _type)
    {
        return getType().equals(_type);
    }
1360297
public static boolean isPrimitive(Object value) {

        if (value == null) {
            return true;

        } else if (value.getClass().isPrimitive() == true) {
            return true;

        } else if (Integer.class.isInstance(value)) {
            return true;

        } else if (Long.class.isInstance(value)) {
            return true;

        } else if (Double.class.isInstance(value)) {
            return true;

        } else if (Float.class.isInstance(value)) {
            return true;

        } else if (Short.class.isInstance(value)) {
            return true;

        } else if (Byte.class.isInstance(value)) {
            return true;

        } else if (Character.class.isInstance(value)) {
            return true;

        } else if (Boolean.class.isInstance(value)) {
            return true;

        } else if (BigDecimal.class.isInstance(value)) {
            return true;

        } else if (BigInteger.class.isInstance(value)) {
            return true;
        }

        return false;
    }