Get the primitive class of the passed primitive wrapper class.

@param aClass
The primitive wrapper class. May be <code>null</code>.
@return <code>null</code> if the passed class is not a primitive wrapper
class.
336873
@Nullable
  public static Class <?> getPrimitiveClass (@Nullable final Class <?> aClass)
  {
    if (isPrimitiveType (aClass))
      return aClass;
    return WRAPPER_TO_PRIMITIVE.get (aClass);
  }
47756
private static Class<?> getRawClass(Type type) {
    if (type instanceof Class) {
      return (Class<?>) type;
    }
    if (type instanceof ParameterizedType) {
      return getRawClass(((ParameterizedType) type).getRawType());
    }
    // For TypeVariable and WildcardType, returns the first upper bound.
    if (type instanceof TypeVariable) {
      return getRawClass(((TypeVariable) type).getBounds()[0]);
    }
    if (type instanceof WildcardType) {
      return getRawClass(((WildcardType) type).getUpperBounds()[0]);
    }
    if (type instanceof GenericArrayType) {
      Class<?> componentClass = getRawClass(((GenericArrayType) type).getGenericComponentType());
      return Array.newInstance(componentClass, 0).getClass();
    }
    // This shouldn't happen as we captured all implementations of Type above (as or Java 8)
    throw new IllegalArgumentException("Unsupported type " + type + " of type class " + type.getClass());
  }
1250282
public static Class<?> wrap(final Class<?> cls) {
        N.checkArgNotNull(cls, "cls");

        final Class<?> wrapped = PRIMITIVE_2_WRAPPER.get(cls);

        return wrapped == null ? cls : wrapped;
    }
810770
private static Class getClass(final String fqcn) {

		try {

			return Class.forName(fqcn);

		} catch (Throwable t) {

		}

		return null;
	}
282929
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
        T result = null;
        if (field != null) {
            result = field.getAnnotation(annotationClass);
        }
        if (result == null && setter != null) {
            result = setter.getAnnotation(annotationClass);
        }
        if (result == null && getter != null) {
            result = getter.getAnnotation(annotationClass);
        }
        return result;
    }
187049
private static Class primitiveToWrapperType(Class clazz) {
	// boolean, byte, char, short, int, long, float, and double
	if (clazz == null) return null;
	else if (clazz.isPrimitive()) {
	    if (clazz.getName().equals("boolean")) return Boolean.class;
	    else if (clazz.getName().equals("byte")) return Byte.class;
	    else if (clazz.getName().equals("char")) return Character.class;
	    else if (clazz.getName().equals("short")) return Short.class;
	    else if (clazz.getName().equals("int")) return Integer.class;
	    else if (clazz.getName().equals("long")) return Long.class;
	    else if (clazz.getName().equals("float")) return Float.class;
	    else if (clazz.getName().equals("double")) return Double.class;
	}
	return clazz;
    }
1350644
private JClassType findClassType( Class<?> clazz ) {
        JClassType mapperType = context.getTypeOracle().findType( clazz.getCanonicalName() );
        if ( null == mapperType ) {
            logger.log( Type.WARN, "Cannot find the type denoted by the class " + clazz.getCanonicalName()
                       + " or GWT compilation of that class failed. In the latter case, compile with -failOnError to discover the real error." );
            return null;
        }
        return mapperType;
    }
478902
public JClass getSuperClass()
  {
    Class cl = _class.getSuperclass();

    if (cl != null)
      return _loader.forName(cl.getName());
    else
      return null;
  }
613152
private JavaClass getSuperclass(JavaClass javaClass) {
    try {
      return javaClass.getSuperClass();
    } catch (ClassNotFoundException e) {
      bugReporter.reportMissingClass(e);
      return null;
    }
  }
1224020
@SuppressWarnings("unchecked")
    public Class loadClass(final SgClass modelClass) {
        Class implClass;
        try {
            implClass = Class.forName(modelClass.getName());
            // The class already exists!
        } catch (final ClassNotFoundException e) {
            implClass = null;
        }
        return implClass;
    }
624768
public static Class<?> getRawClass(Type t) {
		if (isClassType(t)) {
			return typeToClass(t);
		} else if (t instanceof GenericArrayType) {
			Type component = ((GenericArrayType) t).getGenericComponentType();
			return Array.newInstance(getRawClass(component), 0).getClass();
		}
		return Object.class;
	}
99153
public boolean isSuperClassOf(final OClass iClass) {
    OClass cls = iClass;
    while (cls != null) {
      if (cls.getName().equals(name))
        return true;
      cls = cls.getSuperClass();
    }
    return false;
  }
181433
public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz) {
		Assert.notNull(clazz, "Class must not be null");
		return (clazz.isPrimitive() && clazz != void.class? primitiveTypeToWrapperMap.get(clazz) : clazz);
	}
1011326
public XML deleteClass(Class<?> aClass){
		boolean isRemoved = xmlJmapper.classes.remove(new XmlClass(aClass.getName()));
		if(!isRemoved)Error.xmlClassInexistent(this.xmlPath,aClass);
		return this;
	}
295704
protected final Class<T> getEntityClass() {

		@SuppressWarnings("unchecked")
		final Class<T> result = (Class<T>) TypeHelper.getTypeArguments(JpaSearchRepository.class, this.getClass()).get(0);
		return result;
	}
1155191
public static JmsDestinationType getTypeFromClass(String aClass)
    {
        if (StringUtils.equals(aClass, "javax.jms.Queue") || StringUtils.equals(aClass, "javax.jms.QueueConnectionFactory"))
        {
            return JmsDestinationType.QUEUE;
        }
        else if (StringUtils.equals(aClass, "javax.jms.Topic")  || StringUtils.equals(aClass, "javax.jms.TopicConnectionFactory"))
        {
            return JmsDestinationType.TOPIC;
        }
        else
        {
            return null;
        }
    }
105123
public static Class<?> toNonPrimitiveClass(Class<?> clazz) {
        if (clazz.isPrimitive()) {
            Class<?> primitiveClazz = MethodUtils.getPrimitiveWrapper(clazz);
            // the above method returns
            if (primitiveClazz != null) {
                return primitiveClazz;
            } else {
                return clazz;
            }
        } else {
            return clazz;
        }
    }