Gets full class or function name.
5588
def get_full_name(src):
    """"""

    if hasattr(src, "_full_name_"):
        return src._full_name_
    if hasattr(src, "is_decorator"):
        # Our own decorator or binder
        if hasattr(src, "decorator"):
            # Our own binder
            _full_name_ = str(src.decorator)
            # It's a short-living object, so we don't cache result
        else:
            # Our own decorator
            _full_name_ = str(src)
            try:
                src._full_name_ = _full_name_
            except AttributeError:
                pass
            except TypeError:
                pass
    elif hasattr(src, "im_class"):
        # Bound method
        cls = src.im_class
        _full_name_ = get_full_name(cls) + "." + src.__name__
        # It's a short-living object, so we don't cache result
    elif hasattr(src, "__module__") and hasattr(src, "__name__"):
        # Func or class
        _full_name_ = (
            ("<unknown module>" if src.__module__ is None else src.__module__)
            + "."
            + src.__name__
        )
        try:
            src._full_name_ = _full_name_
        except AttributeError:
            pass
        except TypeError:
            pass
    else:
        # Something else
        _full_name_ = str(get_original_fn(src))
    return _full_name_
617902
def classname(ob):
    """"""
    import inspect
    if inspect.isclass(ob):
        return '.'.join([ob.__module__, ob.__name__])
    else:
        return '.'.join([ob.__class__.__module__, ob.__class__.__name__])
935357
def _fullname(o):
    """"""
    return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
366973
public function getClassName()
    {
        $name = str_replace('.', ' ', $this->name);
        $name = str_replace(':', ' pseudo-class-', $name);
        return trim($name);
    }
43812
public function getFullName($className)
    {
        $isFunction = $this->currentMethod && $this->currentMethod instanceof FunctionDefinition;
        $namespace = $isFunction ? $this->currentMethod->getNamespace() : $this->classDefinition->getNamespace();

        return fqcn($className, $namespace, $this->aliasManager);
    }
321716
public static String getShortName(String className) {
		Assert.hasLength(className, "Class name must not be empty");
		int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
		int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR);
		if (nameEndIndex == -1) {
			nameEndIndex = className.length();
		}
		String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
		shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR);
		return shortName;
	}
318535
function getClassName() {
    	preg_match('/\[\s\<\w+?>\s([\w\\\\]+)/s', $this->__toString(), $matches);
    	$class = isset($matches[1]) ? $matches[1] : null;
        if(in_array($class, [ 'array', 'string', 'char', 'bool', 'boolean', 'int', 'integer', 'double', 'float', 'real', 'mixed', 'number', 'null', 'callable', 'callback' ])) {
            return null;
        }
        return $class;
    }
826213
public String getFullFunctionName(ExecutableElement method) {
    return getFullName(ElementUtil.getDeclaringClass(method)) + '_' + getFunctionName(method);
  }
872406
public String getFullMethod(ClassAnnotation primaryClass) {
        if (fullMethod == null) {
            if (Const.CONSTRUCTOR_NAME.equals(methodName)) {
                fullMethod = "new " + stripJavaLang(className) + getSignatureInClass(primaryClass);
            } else {
                fullMethod = stripJavaLang(className) + "." + getNameInClass(primaryClass);
            }
        }

        return fullMethod;
    }
577473
public static String getSimpleClassName(String className) {
		// get the last part of the class name
		String[] parts = className.split("\\.");
		if (parts.length <= 1) {
			return className;
		} else {
			return parts[parts.length - 1];
		}
	}
374041
def _get_function_name(self):
        
        fname = inspect.getframeinfo(inspect.stack()[2][0]).function
        if fname == "<module>":
            return ""
        else:
            return fname
905373
def get_class_qualname(cls):
    
    if hasattr(cls, '__qualname__'):
        return cls.__qualname__
    module = sys.modules[cls.__module__]
    if cls.__module__ == 'typing' and not hasattr(cls, '__name__'):
        # Python 3.7
        return cls._name
    if hasattr(module, cls.__name__) and getattr(module, cls.__name__) is cls:
        return cls.__name__
    else:
        nst = _get_class_nesting_list(cls, module)
        nst.append(cls)
        nst = [cl.__name__ for cl in nst]
        return '.'.join(nst)
    return cls.__name__
1285363
public function getFullClassName($class)
    {
        // Rootclass
        if ($class[0] === '\\') {
            return $class;
        }

        $classParts = explode('\\', $class);
        $className  = array_pop($classParts);
        $firstPart  = array_shift($classParts);
        $middlePart = implode('\\', $classParts) ?: null;
        $found      = false;

        // Rewind the uses array
        $this->uses->rewind();

        // Check if the class has been 'used'
        foreach ($this->uses as $use) {
            if ($firstPart === null) {
                if ($use->getAlias() === $className || preg_match("/\\\\?{$className}$/", $use->getName())) {
                    // Mark class as 'found'
                    $found = true;

                    // The use is a full class include
                    $class = $use->getName();

                    break;
                }
            } else {
                if (preg_match("/{$firstPart}$/", $use->getAlias()) || preg_match("/{$firstPart}$/", $use->getName())) {
                    $class = "{$use->getName()}" . ($middlePart ? "\\{$middlePart}" : '') . "\\{$className}";
                    $found = true;
                    break;
                }
            }
        }

        // Nothing matches, check the class namespace
        if ($found === false) {
            $class = "{$this->namespace}\\{$class}";
        }

        // Check if the class exists
        return $class;
    }
18041
public static String getFullClassName(String packageName, String className) {
    	return ClassServiceUtility.getFullClassName(null, packageName, className);
    }
1205844
def classes(
            self,
            name=None,
            function=None,
            header_dir=None,
            header_file=None,
            recursive=None,
            allow_empty=None):
        """"""
        return (
            self._find_multiple(
                self._impl_matchers[scopedef_t.class_],
                name=name,
                function=function,
                decl_type=self._impl_decl_types[
                    scopedef_t.class_],
                header_dir=header_dir,
                header_file=header_file,
                recursive=recursive,
                allow_empty=allow_empty)
        )
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
511967
public static String getShortClassName(Object o) {
    String name = o.getClass().getName();
    int index = name.lastIndexOf('.');
    if (index >= 0) {
      name = name.substring(index + 1);
    }
    return name;
  }