Returns the fully qualified class name from the base generator command in a Laravel 5.3/5.4
compatible manner

@param string    $name

@throws UnknownLaravelVersionException

@return string
497101
protected function getFQCNComp($name)
    {
        if (method_exists($this, 'qualifyClass')) {
            return $this->qualifyClass($name);
        } elseif (method_exists($this, 'parseName')) {
            return $this->parseName($name);
        } else {
            throw new UnknownLaravelVersionException(
                sprintf(
                    "There's an incompatible parent class `%s` in your installed version of Laravel",
                    get_parent_class($this)
                )
            );
        }
    }
357076
protected static function getAlgorithm($name)
    {
        if (!isset(self::$algorithms[$name])) {
            self::$algorithms[$name] = new $name();
        }

        return self::$algorithms[$name];
    }
860267
public function getCommandNamed($name)
    {
        foreach ($this->commands as $command) {
            if ($name === $command->getName()) {
                return $command;
            }
        }

        throw new DcGeneralInvalidArgumentException('Command with name ' . $name . ' not found');
    }
172380
public function getItemName($name)
    {
        $lowerName = strtolower($name);
        foreach ([
             $this->classNames,
             $this->interfaceNames,
             $this->traitNames,
         ] as $source) {
            if (isset($source[$lowerName])) {
                return $source[$lowerName];
            }
        }
        return null;
    }
1250694
public static function ModulePath($name)
    {
        // BC for a couple fo the key modules in the old syntax. Reduces merge brittleness but can
        // be removed before 4.0 stable
        $legacyMapping = [
            'framework' => 'silverstripe/framework',
            'frameworkadmin' => 'silverstripe/admin',
        ];
        if (isset($legacyMapping[$name])) {
            $name = $legacyMapping[$name];
        }

        return ModuleLoader::getModule($name)->getRelativePath();
    }
134871
public function getClassName($name)
    {
        $name = $this->_formatName($name);
        if ($this->_useStaticRegistry
            && isset(self::$_staticLoadedPlugins[$this->_useStaticRegistry][$name])
        ) {
            return self::$_staticLoadedPlugins[$this->_useStaticRegistry][$name];
        } elseif (isset($this->_loadedPlugins[$name])) {
            return $this->_loadedPlugins[$name];
        }

        return false;
    }
828811
protected function getMigrationFullName($name)
    {
        $folder = '';

        if (Config::organizeMigrations()) {
            $folder = $this->tableName;
        }

        return str_finish($this->getMigrationPath($folder) . DIRECTORY_SEPARATOR . $name, '.php');
    }
1356268
public static function __getClassPath($name)
    {
        if (is_file(EMAILGATEWAYS . "/email.$name.php")) {
            return EMAILGATEWAYS;
        } else {
            $extensions = Symphony::ExtensionManager()->listInstalledHandles();

            if (is_array($extensions) && !empty($extensions)) {
                foreach ($extensions as $e) {
                    if (is_file(EXTENSIONS . "/$e/email-gateways/email.$name.php")) {
                        return EXTENSIONS . "/$e/email-gateways";
                    }
                }
            }
        }

        return false;
    }
1276845
protected function createClassName(string $name): string
    {
        $result = str_replace('_', ' ', $name);

        return str_replace(' ', '', ucwords($result));
    }
590005
protected function convertToFullQualifyClassName($name)
    {
        if (Str::contains($name, '/')) {
            $name = str_replace('/', '\\', $name);
        }

        if (Str::startsWith($name, '\\')) {
            $name = substr($name, 1);
        }
        else {
            $name = $this->getDefaultNamespace().'\\'.$name;
        }

        return $this->filterFullQualifyClassName($name, function ($part) {
            return ucfirst($part);
        });
    }
446977
protected function getModelName($name = null)
    {
        $name = isset($name) ? $name : $this->resource;

        //return ucwords(camel_case($this->getResourceName($name)));

        return str_singular(ucwords(camel_case(class_basename($name))));
    }
1198805
protected function getModelNamespace(string $name):string
    {
        if ($this->option('model')) {
            return $this->option('model');
        }

        return 'App\\' . str_replace('Transformer', '', $name);
    }
588532
public function get($name)
    {
        $names = explode(self::SEPARATOR, $name);
        $method = array_pop($names);
        if ($names) {
            $class_name = 'Task\\' . join('\\', array_map('ucfirst', $names)) . 'TaskList';
        } else {
            $class_name = 'Task\\TaskList';
        }
        $class_path = $this->loader->getPathByClass($class_name, false);
        if ($class_path === null || ! $class_path->isExists()) throw new NotFoundException("No such task. -> {$name}");

        require_once $class_path;
        $class_name = $class_path->getClassName();
        $taskList = new $class_name();
        $taskList->setOutput($this->output);
        $taskList->setContainer($this->raikiri());
        if (! $taskList->has($method)) throw new NotImplementsException("No such task. -> {$name}");

        return $taskList->get($method);
    }
1071567
public function getDefinition($name)
    {
        if (!class_exists($name) && !interface_exists($name)) {
            return null;
        }

        $class = new \ReflectionClass($name);
        if(isset($name::$__enableDIAnnotations__) && $name::$__enableDIAnnotations__){
            $context = $this->loader->build($name);
            /**@var $context ObjectDefinitionContext */
            $definition = $context->definition;
        }else{
            $definition = new ObjectDefinition($name);
        }

        $constructor = $class->getConstructor();
        if ($constructor && $constructor->isPublic()) {
            $definition->setConstructorInjection(
                MethodInjection::constructor($this->getParametersDefinition($constructor))
            );
        }

        return $definition;
    }
658159
private function getClassContentClassnamesByCategory($name)
    {
        try {
            return $this->getCategoryManager()->getClassContentClassnamesByCategory($name);
        } catch (\InvalidArgumentException $e) {
            throw new NotFoundHttpException($e->getMessage());
        }
    }
448676
public static function serviceClassname($name)
    {
        $services = static::services();

        if (!isset($services[$name])) {
            throw new \InvalidArgumentException(
                sprintf('The provided service %s does not exist.', $name)
            );
        }

        return $services[$name];
    }
855492
private function getRichFieldName(string $name): string
    {
        $this->initRichModelUtils();
        $exceptedName = \lcfirst($name);

        $field = $this->richAccessMapExists ? null : $exceptedName;

        if ($this->richAccessMapExists) {
            if (\array_key_exists($exceptedName, $this->richAccessMapArray)) {
                $field = $this->richAccessMapArray[$exceptedName];
            } elseif (!\array_key_exists(RichModelInterface::RICH_STRICT, $this->richAccessMapArray)) {
                $field = $exceptedName;
            }
        }

        if (!$field || !$this->richClassReflection->hasProperty($field)) {
            throw new RichModelFieldException(\sprintf('Field "%s" (remapped: %s) not found!', $name, $field));
        }

        return $field;
    }