Returns the full class name of the specified class.  This method
provides special formatting for inner classes.
355258
public String getFullClassName(String fullClassName) {

        String[] parts = parseClassName(fullClassName);             

        String className = getInnerClassName(parts[1]);
        
        if (parts[0] != null) {
            // Return the package name plus the converted class name
            return parts[0] + '.' + className;
        }
        else {
            return className;
        }
    }
365582
def class_name(self, cls, parts=0, aliases=None):
        # type: (Any, int, Optional[Dict[unicode, unicode]]) -> unicode
        
        module = cls.__module__
        if module in ('__builtin__', 'builtins'):
            fullname = cls.__name__
        else:
            fullname = '%s.%s' % (module, cls.__name__)
        if parts == 0:
            result = fullname
        else:
            name_parts = fullname.split('.')
            result = '.'.join(name_parts[-parts:])
        if aliases is not None and result in aliases:
            return aliases[result]
        return result
1129179
def lookup_class(fully_qualified_name):
    
    module_name, class_name = str(fully_qualified_name).rsplit(".", 1)
    module = __import__(module_name, globals(), locals(), [class_name], 0)
    Class = getattr(module, class_name)

    if not inspect.isclass(Class):
        raise TypeError(
            "%s is not of type class: %s" % (class_name, type(Class)))

    return Class
1368343
public static String getShortClassName( Class<?> clazz )
    {
        String className = clazz.getName();
        int idx = className.lastIndexOf('.');
        return (idx == -1 ? className : className.substring(idx+1));
    }
389519
public static String getClassName( final Class<?> clazz ) {
        final String fullName = clazz.getName();
        final int fullNameLength = fullName.length();

        // Check for array ('[') or the class/interface marker ('L') ...
        int numArrayDimensions = 0;
        while (numArrayDimensions < fullNameLength) {
            final char c = fullName.charAt(numArrayDimensions);
            if (c != '[') {
                String name = null;
                // Not an array, so it must be one of the other markers ...
                switch (c) {
                    case 'L': {
                        name = fullName.subSequence(numArrayDimensions + 1, fullNameLength).toString();
                        break;
                    }
                    case 'B': {
                        name = "byte";
                        break;
                    }
                    case 'C': {
                        name = "char";
                        break;
                    }
                    case 'D': {
                        name = "double";
                        break;
                    }
                    case 'F': {
                        name = "float";
                        break;
                    }
                    case 'I': {
                        name = "int";
                        break;
                    }
                    case 'J': {
                        name = "long";
                        break;
                    }
                    case 'S': {
                        name = "short";
                        break;
                    }
                    case 'Z': {
                        name = "boolean";
                        break;
                    }
                    case 'V': {
                        name = "void";
                        break;
                    }
                    default: {
                        name = fullName.subSequence(numArrayDimensions, fullNameLength).toString();
                    }
                }
                if (numArrayDimensions == 0) {
                    // No array markers, so just return the name ...
                    return name;
                }
                // Otherwise, add the array markers and the name ...
                if (numArrayDimensions < BRACKETS_PAIR.length) {
                    name = name + BRACKETS_PAIR[numArrayDimensions];
                } else {
                    for (int i = 0; i < numArrayDimensions; i++) {
                        name = name + BRACKETS_PAIR[1];
                    }
                }
                return name;
            }
            ++numArrayDimensions;
        }

        return fullName;
    }
372265
public static String transformClassName(String className) {
        int lastDot = className.lastIndexOf('.');
        if (lastDot >= 0) {
            String pkg = className.substring(0, lastDot);
            if (!isUnlikelyToBeRenamed(pkg)) {
                className = className.substring(lastDot + 1);
            }
        }
        return className;
    }
930522
private String computeShortClassName() {
        String name = this.getClass().getSimpleName();
        if (name.endsWith(APP_SUFFIX_CLASSNAME)) {
            name = name.substring(0, name.indexOf(APP_SUFFIX_CLASSNAME));
        }
        return name;
    }
55047
def fullname(self):
        """"""
        if not self.bound:
            if self.name is not None:
                return "(unbound).%s" % self.name
            else:
                return "(unbound)"
        elif not self.class_():
            classname = "(GC'd class)"
        else:
            classname = self.class_().__name__
        return "%s.%s" % (classname, self.name)
1359801
def mk_class_name(*parts):
    """"""
    cap = lambda s: s and (s[0].capitalize() + s[1:])
    return "".join(["".join([cap(i)
                             for i in re.split("[\ \-\_\.]", str(p))])
                    for p in parts])
82190
public Class<?> getClassForName(String className) {
        if (!StringUtils.hasText(className)) {
            return null;
        }

        for (Class<?> c : allClasses) {
            if (c.getName().equals(className)) {
                return c;
            }
        }
        return null;
    }
475637
public static String extractSimpleClassName(Description description) {
        String simpleClassName = null;
        final String className = extractClassName(description);
        final String[] splitClassName = className.split("\\.");

        if (splitClassName.length > 0) {
            simpleClassName = splitClassName[splitClassName.length - 1];
        }

        return simpleClassName;
    }
1374064
public static Class<?> getNamedClass(Object obj) {
		Class<?> cls = getClass(obj);
		while (cls != null && cls.isAnonymousClass()) {
			cls = cls.getEnclosingClass();
		}
		return cls;
	}
55250
public static String getFullClassName(String className) {
        final int i = className.indexOf('$');
        if (i > -1) {
            className = className.substring(0, i);
        }
        return className;
    }
380131
def search_get_class_names(cls):
        
        if hasattr(cls, '_class_key'):
            class_names = []
            for n in cls._class_key():
                class_names.append(n)
            return class_names
        else:
            return [cls.__name__]
859086
def _full_class_name(obj):
    
    module = obj.__class__.__module__
    if module is None or module == str.__class__.__module__:
        return obj.__class__.__name__
    return module + "." + obj.__class__.__name__
1080324
public String getFullName()
  {
    StringBuilder name = new StringBuilder();

    name.append(getName());
    name.append("(");

    JClass []params = getParameterTypes();
    for (int i = 0; i < params.length; i++) {
      if (i != 0)
        name.append(", ");

      name.append(params[i].getShortName());
    }

    name.append(')');

    return name.toString();
  }
328693
public static synchronized String getName(Class writableClass) {
    String name = CLASS_TO_NAME.get(writableClass);
    if (name != null)
      return name;
    return writableClass.getName();
  }