Gets resolved name from current namespace. Note that this is not necessarily the *actual* name
that is resolved during compilation or at runtime. For that, see QualifiedName::getResolvedName().

@return ResolvedName
174467
public function getNamespacedName() : ResolvedName {
        $namespaceDefinition = $this->getNamespaceDefinition();
        $content = $this->getFileContents();
        if ($namespaceDefinition === null) {
            // global namespace -> strip namespace\ prefix
            return ResolvedName::buildName($this->getNameParts(), $content);
        }

        if ($namespaceDefinition->name !== null) {
            $resolvedName = ResolvedName::buildName($namespaceDefinition->name->nameParts, $content);
        } else {
            $resolvedName = ResolvedName::buildName([], $content);
        }
        if (
            !($this instanceof QualifiedName && (
            ($this->parent instanceof NamespaceDefinition) ||
            ($this->parent instanceof NamespaceUseDeclaration) ||
            ($this->parent instanceof NamespaceUseClause) ||
            ($this->parent instanceof NamespaceUseGroupClause)))
        ) {
            $resolvedName->addNameParts($this->getNameParts(), $content);
        }
        return $resolvedName;
    }
241907
private function getStdSeparatedName()
    {
        if ($this->schema && $this->getBuildProperty('generator.schema.autoPrefix')) {
            return $this->schema . NameGeneratorInterface::STD_SEPARATOR_CHAR . $this->getCommonName();
        }

        return $this->getCommonName();
    }
795253
public function resolveName(
        PurchasableInterface $purchasable,
        $separator = null
    ) {
        $namespace = $this->getPurchasableNamespace();
        if (!$purchasable instanceof $namespace) {
            return false;
        }

        /**
         * @var $purchasable ProductInterface
         */
        return $purchasable->getName();
    }
886768
protected function _referenceName()
    {
        $table = $this->_table;
        $name = namespaceSplit(get_class($table));
        $name = substr(end($name), 0, -5);
        if (empty($name)) {
            $name = $table->getTable() ?: $table->getAlias();
            $name = Inflector::camelize($name);
        }

        return $name;
    }
935347
final public static function resolveName($value): ?string
    {
        if ($value instanceof DomainId) {
            $class = \get_class($value);

            /** @var string $type */
            foreach (self::$mapping as $type => $mapping) {
                if ($class === $mapping['class']) {
                    return $type::NAME;
                }
            }

            return self::NAME;
        }

        return null;
    }
648537
public function getBundleName(): ?string
    {
        if ($this->getBundleNamespace() === static::NO_BUNDLE_NAMESPACE) {
            return null;
        }
        if (strpos('\\', $this->getBundleNamespace()) !== false) {
            $parts = explode('\\', $this->getBundleNamespace());
            return array_pop($parts);
        }
        return $this->getBundleNamespace();
    }
890639
public function getName()
    {
        if (null === $this->name)
        {
            $this->name = strtolower(get_class($this));
        }
        return $this->name;
    }
811527
public function getQName()
	{
		// Use the cached name if there is one.
		if ( ! $this->qname )
		{
			if ( ! property_exists( $this, 'name' ) ) return null;
			$this->qname = $qname = new QName( $this->name['originalPrefix'], $this->name['namespace'], $this->name['name'] );
		}

		return $this->qname;
	}
952261
public function get_name() {
        if (get_string_manager()->string_exists('pluginname', $this->component)) {
            return get_string('pluginname', $this->component);
        }
        return $this->store;
    }
1272362
public function getName( $prefixed = TRUE ){
		if( $prefixed )
			return $this->prefix.$this->name;
		return $this->name;
	}
235681
public function getNormalizedName()
    {
        if ($this->normalizedName === null) {
            $this->normalizedName = implode('_', $this->getAncestorsNames());
        }
        return $this->normalizedName;
    }
879869
private String resolveName() {
		if (this.readMethod != null) {
			int index = this.readMethod.getName().indexOf("get");
			if (index != -1) {
				index += 3;
			}
			else {
				index = this.readMethod.getName().indexOf("is");
				if (index == -1) {
					throw new IllegalArgumentException("Not a getter method");
				}
				index += 2;
			}
			return StringUtils.uncapitalize(this.readMethod.getName().substring(index));
		}
		else {
			int index = this.writeMethod.getName().indexOf("set") + 3;
			if (index == -1) {
				throw new IllegalArgumentException("Not a setter method");
			}
			return StringUtils.uncapitalize(this.writeMethod.getName().substring(index));
		}
	}
426844
protected function resolveName(Name $name, $type) {
        $resolvedName = $this->nameContext->getResolvedName($name, $type);
        if (null !== $resolvedName) {
            $name->setAttribute('resolvedName', $resolvedName->toString());
        }
        return $name;
    }
252826
public function getNamespace()
    {
        if (!isset($this->namespace)) {
            $reflectionClass = new \ReflectionClass($this->name);
            $this->namespace = $reflectionClass->getNamespaceName();
        }
        return $this->namespace;
    }
1156789
private function getName($prefixed = true)
    {
        return $this->clean(
            $prefixed ? $this->prefix.$this->name : $this->name
        );
    }
323859
public function resolve(ClassName $className)
    {
        if ($className->isAbsolute()) {
            return $className;
        } elseif ($className->isShortName()) {
            $usedClass = $this->usedClass($className);
            if (null !== $usedClass) {
                return $usedClass;
            }
        }

        if (null !== $this->namespaceName()) {
            return $this->namespaceName()->join($className);
        }

        return $className->toAbsolute();
    }
328724
public static function name()
    {
        $class = get_called_class();
        if (!isset(self::$names[$class])) {
            self::$names[$class] = self::generateName($class);
        }

        return self::$names[$class];
    }