Returns the class name of this hash, possibly
taking the parent element into the name. this
string here results in the name of the generated Document.

@param boolean $fq if true, we'll return the class name full qualified

@return string
961692
private function getClassName($fq = false)
    {
        $className = ucfirst($this->parent->getId()).ucfirst($this->getName());
        if ($fq) {
            $className = $this->parent->getNamespace().'\\Document\\'.$className;
        }

        return $className;
    }
55250
public static String getFullClassName(String className) {
        final int i = className.indexOf('$');
        if (i > -1) {
            className = className.substring(0, i);
        }
        return className;
    }
94771
private static String getAnnotationFqName(AnnotationMirror annotation) {
    return ((QualifiedNameable) annotation.getAnnotationType().asElement())
        .getQualifiedName()
        .toString();
  }
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;
    }
198677
private function getClassName()
    {
        if (null === $this->className) {
            $this->className = get_class($this);
        }

        return $this->className;
    }
241497
final public static function className(string $fullName = null): string
    {
        $fullName = $fullName ?: self::fullName();
        $fullName = str_replace('\\', '/', $fullName);

        return basename($fullName);
    }
433439
public function getName($autoGenerate = true)
    {
        if (!empty($this->_name)) {
            return $this->_name;
        }
        if ($autoGenerate) {
            $reflection = new \ReflectionClass($this);
            $this->_name = self::$autoNamePrefix . Inflector::variablize(
                    $reflection->getShortName()
                ) . self::$counter++;
        }
        return $this->_name;
    }
483758
protected function filterFullQualifyClassName($fqcn, callable $callback)
    {
        $parts = explode('\\', $fqcn);

        foreach ($parts as &$part) {
            $part = call_user_func($callback, $part);
        }

        return implode('\\', $parts);
    }
527968
protected function _getClassForElement($elementClass = null) {
		$elementClass = mb_strtolower((string)$elementClass);
		$cachePath = 'ClassForElem.' . md5($elementClass);
		$cached = Cache::read($cachePath, CAKE_THEME_CACHE_KEY_HELPERS);
		if (!empty($cached)) {
			return $cached;
		}

		$result = '';
		if (empty($elementClass)) {
			return $result;
		}

		if (mb_strpos($elementClass, 'fa-') !== false) {
			$elemList = [];
			$elemPrefixes = $this->_getListIconPrefixes();
			$elemPrefix = (string)$this->_config['defaultIconPrefix'];
			$elemSizes = $this->_getListIconSizes();
			$elemSize = (string)$this->_config['defaultIconSize'];
		} elseif (mb_strpos($elementClass, 'btn-') !== false) {
			$elemList = $this->_getListButtons();
			$elemPrefixes = $this->_getListButtonPrefixes();
			$elemPrefix = (string)$this->_config['defaultBtnPrefix'];
			$elemSizes = $this->_getListButtonSizes();
			$elemSize = (string)$this->_config['defaultBtnSize'];
		} else {
			return $result;
		}
		$aElem = explode(' ', $elementClass, 5);
		$aClass = [];
		foreach ($aElem as $elemItem) {
			if (empty($elemItem)) {
				continue;
			}

			if (in_array($elemItem, $elemSizes)) {
				$elemSize = $elemItem;
			} elseif (in_array($elemItem, $elemPrefixes)) {
				$elemPrefix = $elemItem;
			} elseif (empty($elemList) || (!empty($elemList) && in_array($elemItem, $elemList))) {
				$aClass[] = $elemItem;
			}
		}
		if (!empty($elemList) && empty($aClass)) {
			return $result;
		}

		if (!empty($elemPrefix)) {
			array_unshift($aClass, $elemPrefix);
		}
		if (!empty($elemSize)) {
			array_push($aClass, $elemSize);
		}
		$aClass = array_unique($aClass);
		$result = implode(' ', $aClass);
		Cache::write($cachePath, $result, CAKE_THEME_CACHE_KEY_HELPERS);

		return $result;
	}
663073
public static function getClassNameFromFQN(string $name): string
    {
        $arr = explode('\\', $name);

        return (string)array_pop($arr);
    }
443715
protected function getClassName(ClassNode $classNode): string
    {
        if ($classNode instanceof ClassNode) {
            return $classNode->getNamespaceName() . '\\' . $classNode->getName();
        }

        return $classNode->getFullQualifiedName();
    }
1223621
@Override
	public String getClassName() {

		String name = getProperty(AbstractNode.name);
		if (name == null) {

			final String _sourceType = getSchemaNodeSourceType();
			final String _targetType = getSchemaNodeTargetType();
			final String _relType    = SchemaHelper.cleanPropertyName(getRelationshipType());

			name = _sourceType + _relType + _targetType;

			try {
				setProperty(AbstractNode.name, name);

			} catch (FrameworkException fex) {
				logger.warn("Unable to set relationship name to {}.", name);
			}
		}

		return name;
	}
779253
public function getHydratorClassName($fqcn)
    {
        $config = new Configuration($fqcn);
        $config->setAutoGenerateProxies($this->generateProxies);
        $config->setGeneratedClassesTargetDir($this->cacheDir);

        return $config->createFactory()->getHydratorClass();
    }
366673
public function getChildDefinitionsForFqn(string $fqn): \Generator
    {
        $parts = $this->splitFqn($fqn);
        if ('' === end($parts)) {
            // we want to return all the definitions in the given FQN, not only
            // the one (non member) matching exactly the FQN.
            array_pop($parts);
        }

        $result = $this->getIndexValue($parts, $this->definitions);
        if (!$result) {
            return;
        }
        foreach ($result as $name => $item) {
            // Don't yield the parent
            if ($name === '') {
                continue;
            }
            if ($item instanceof Definition) {
                yield $fqn.$name => $item;
            } elseif (is_array($item) && isset($item[''])) {
                yield $fqn.$name => $item[''];
            }
        }
    }
557475
public function getName()
    {
        $fqdnClassName = get_class($this);
        $className = substr($fqdnClassName, strrpos($fqdnClassName, '\\') + 1);
        return str_replace("Service", "", $className);
    }
1148610
public static function ofClass($fullName)
    {
        $result = self::of($fullName);
        if (!($result instanceof ClassType))
            throw new InvalidArgumentException("Argument 'fullName' does not describe a class.");
        return $result;
    }
988123
public function getName($ucfirst = false)
    {
        $value = $this->camelCase($this->name);
        if (true === $ucfirst) {
            return ucfirst($value);
        } else {
            return $value;
        }
    }