Resolve the convention class

@param string $name Either a short name like 'default' or an FQCN

@return string
324548
private function resolveConventionClass(string $name)
    {
        if ('default' == $name) {
            return ConcordDefault::class;
        } elseif (class_exists($name)) {
            return $name;
        }

        throw new InvalidArgumentException(
            sprintf('%s is not a valid convention class', $name)
        );
    }
1315484
public static function validateConstant($name)
    {
        $name = self::validateNamingConvention($name);
        if (self::isKeyword($name)) {
            $name = self::NAME_PREFIX . ucfirst($name);
        }
        return $name;
    }
1035226
final public function getDefaultPort($name)
	{
		$this->_getPortKey($name);
		if ($this->isNamedPort($name)) {
			return constant($this->_port_class . $name);
		} else {
			throw new \InvalidArgumentException("Unknown name or scheme: {$name}");
		}
	}
1236495
public function resolve(string $namespace, string $version, string $name): string
    {
        $class = str_replace('.', '\\', $name);

        if (! array_key_exists($version, $this->supportedVersions)) {
            $version = $this->defaultVersion;
        }

        return sprintf('%s\%s\%s\%s', $namespace, $this->supportedVersions[$version], $class);
    }
1130440
protected function qualifyClass($name)
    {
        try {
            $location = $this->option('location') ?: config('modules.default_location');
        }
        catch (\Exception $e) {
            $location = config('modules.default_location');
        }

        $rootNamespace = config("modules.locations.$location.namespace");

        if (Str::startsWith($name, $rootNamespace)) {
            return $name;
        }

        $name = str_replace('/', '\\', $name);

        return $this->qualifyClass(
            $this->getDefaultNamespace(trim($rootNamespace, '\\')).'\\'.$name
        );
    }
1338719
private function resolveName($name)
    {
        if ($name !== null) {
            return $name;
        }

        if (!isset($this->defaults['route'])) {
            throw new RouterException('Unable to make "self" url - default route was not defined.');
        }

        return $this->defaults['route'];
    }
912889
public function getConstantDefinition($name) {
		if (isset($this->constantsDef[$name])) {
			return $this->constantsDef[$name];
		} else {
			return null;
		}
	}
701191
public function resolve($name)
    {
        if ((new SupportsCacheTags())->isSatisfiedBy($this->cache)) {
            $userId   = $this->guard->check() ? $this->guard->user()->getAuthIdentifier() : null;
            $duration = $this->config->get('sidebar.cache.duration');

            return $this->cache->tags(CacheKey::get($name))->remember(CacheKey::get($name, $userId), $duration, function () use ($name) {
                return $this->resolver->resolve($name);
            });
        }
    }
1112844
private function resolveFileName($name): string
    {
        $filename = $this->getFilename($name);
        if ($filename === false) {
            throw new LoaderError(sprintf('Template "%s" is not defined.', $name));
        }

        return $filename;
    }
949735
protected function defaultBuildClass($name): string
    {
        $stub = $this->files->get($this->getStub());

        return $this->replaceNamespace($stub, $name)->replaceClass($stub, $name);
    }
1273255
protected function resolveKey($name)
    {
        if (false !== $pos = strrpos($name, $this->namespaceCharacter)) {
            $name = substr($name, $pos + 1);
        }

        return $name;
    }
584976
protected function resolveTemplateName($name)
    {
        $prefix = $this->templatePath;
        if ($this->templatePath !== null && $this->templatePath !== '') {
            $prefix = rtrim($prefix, '/').'/';
        }

        return $prefix.$name;
    }
539516
private function resolveChild(string $name): FormBuilderInterface
    {
        list($type, $options) = $this->unresolvedChildren[$name];

        unset($this->unresolvedChildren[$name]);

        return $this->children[$name] = $this->create($name, $type, $options);
    }
597862
public function resolved($name) {
		$name = $this->getAlias($name);

		return array_key_exists($name, $this->instances);
	}
1343453
public function getValueType($name)
    {
        if (!$this->isParsed) {
            $this->parseDefinitions();
        } //if

        $longName = (strlen($name) == 1 ? ( isset($this->shortNames[$name]) ? $this->shortNames[$name] : '') : $name);

        if (isset($this->longNames[$longName]['parameterType'])
            && $this->longNames[$longName]['parameterType'] !== false) {
            return $this->longNames[$longName]['parameterType'];
        } else {
            return '';
        } //if
    }
955661
protected static function resolveFacadeInstance($name)
    {
        if (is_object($name)) return $name;

        if (isset(static::$resolvedInstance[$name])) {
            return static::$resolvedInstance[$name];
        }

        return static::$resolvedInstance[$name] = static::$app[$name];
    }
647321
public function resolveClassName($alias)
    {
        // Make sure we have string, type-cast Contenttype if needed.
        $alias = (string) $alias;

        if (class_exists($alias)) {
            return $alias;
        }

        if (array_key_exists($alias, $this->aliases)) {
            $class = $this->aliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }
        if (array_key_exists($alias, $this->defaultAliases)) {
            $class = $this->defaultAliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }
        if (array_key_exists($alias, $this->defaultAliases)) {
            $class = $this->defaultAliases[$alias];
            if (class_exists($class)) {
                return $class;
            }
        }

        return $this->fallbackEntity;
    }