Get the type signature of the class.

@return The class type signature, if available, otherwise returns null.
4205
public ClassTypeSignature getTypeSignature() {
        if (typeSignatureStr == null) {
            return null;
        }
        if (typeSignature == null) {
            try {
                typeSignature = ClassTypeSignature.parse(typeSignatureStr, this);
                typeSignature.setScanResult(scanResult);
            } catch (final ParseException e) {
                throw new IllegalArgumentException(e);
            }
        }
        return typeSignature;
    }
1228106
public Class<?> getClassType() {
        try {
            return Class.forName(getType(), true, ClassLoaderHolder.getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }
1245604
private ClassTypeSignature getClassTypeSignature(
			ParameterizedType parameterizedType) {
		Class<?> rawType = (Class<?>) parameterizedType.getRawType();
		Type[] typeArguments = parameterizedType.getActualTypeArguments();
		TypeArgSignature[] typeArgSignatures = new TypeArgSignature[typeArguments.length];
		for (int i = 0; i < typeArguments.length; i++) {
			typeArgSignatures[i] = getTypeArgSignature(typeArguments[i]);
		}

		String binaryName = rawType.isMemberClass() ? rawType.getSimpleName()
				: rawType.getName();
		ClassTypeSignature ownerTypeSignature = parameterizedType
				.getOwnerType() == null ? null
				: (ClassTypeSignature) getFullTypeSignature(parameterizedType
						.getOwnerType());
		ClassTypeSignature classTypeSignature = new ClassTypeSignature(
				binaryName, typeArgSignatures, ownerTypeSignature);
		return classTypeSignature;
	}
814283
public com.sun.javadoc.Type superclassType() {
        if (asClassDoc().isInterface()) {
            return null;
        }
        Type sup = env.types.supertype(type);
        return TypeMaker.getType(env,
                                 (sup != type) ? sup : env.syms.objectType);
    }
716250
public Class<?> getType(String key) {
        Object val = this.data.get(key);
        return val == null ? null : val.getClass();
    }
1230814
public String getFormalClassName()
    {
        StringBuffer sb = new StringBuffer(getClassName());
        sb.append(getFormalTypeParameterNames());
        return sb.toString();
    }
861664
private String getType(final WComponent component) {
		for (Class<?> clazz = component.getClass(); clazz != null && WComponent.class.
				isAssignableFrom(clazz); clazz = clazz.getSuperclass()) {
			if ("com.github.bordertech.wcomponents".equals(clazz.getPackage().getName())) {
				return clazz.getName();
			}
		}

		return null;
	}
927672
private String getClassName(final TypeMirror t) {
        String res = null;

        if (t instanceof DeclaredType) {
            final DeclaredType dt = (DeclaredType) t;
            res = ((TypeElement) dt.asElement()).getQualifiedName().toString();
        }

        return res;
    }
756387
public String getReturnTypeSignature() {
        int endOfParams = signature.lastIndexOf(')');
        if (endOfParams < 0) {
            throw new IllegalArgumentException("Bad method signature: " + signature);
        }
        return signature.substring(endOfParams + 1);
    }
323779
public String getType() {

        if ((m_mapping != null) && (m_mapping.getType() != null)) {
            return m_mapping.getType().toString();
        }
        return "";
    }
1316102
@Override
	public JvmType getType() {
		if (type == null) {
			JvmGenericType objectType = TypesFactory.eINSTANCE.createJvmGenericType();
			String objectClassName = Object.class.getName();
			((InternalEObject) objectType).eSetProxyURI(URIHelperConstants.OBJECTS_URI.appendSegment(objectClassName).appendFragment(objectClassName));
			setType(objectType);
		}
		return super.getType();
	}
825762
public Class<?> getType() {
        Class<?> cl = getTypeInternal();
        if (isDeserialized && !cl.isPrimitive()) {
            return Object.class;
        }
        return cl;
    }
701720
public static Class<?> getTypeParameter(Class<?> genericType, Class<?> type) {
        Type[] genericInterfaces = type.getGenericInterfaces();
        for (Type genericInterface : genericInterfaces) {
            if (genericInterface instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
                if (genericType.equals(parameterizedType.getRawType())) {
                    Type typeParameter = ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
                    if (typeParameter instanceof Class<?>) {
                        return (Class<?>) typeParameter;
                    }
                }
            }
        }
        return null;
    }
1307952
public static Class<?> getClass(Type type) {
		if (null != type) {
			if (type instanceof Class) {
				return (Class<?>) type;
			} else if (type instanceof ParameterizedType) {
				return (Class<?>) ((ParameterizedType) type).getRawType();
			} else if (type instanceof TypeVariable) {
				return (Class<?>) ((TypeVariable<?>) type).getBounds()[0];
			} else if (type instanceof WildcardType) {
				final Type[] upperBounds = ((WildcardType) type).getUpperBounds();
				if (upperBounds.length == 1) {
					return getClass(upperBounds[0]);
				}
			}
		}
		return null;
	}
73113
@NullSafe
  public static String getSimpleName(Class type) {
    return type != null ? type.getSimpleName() : null;
  }
182409
@SuppressWarnings("unchecked")
  protected Class<T> getParameterizedType() {
    Class<T> clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass())
        .getActualTypeArguments()[0];
    return clazz;
  }
115246
public Class<I> getImplClass() {
    return _impl_class != null ? _impl_class : (_impl_class = ReflectionUtils.findActualClassParameter(this.getClass(), 0));
  }