Find the controller name by our convention of {$ModelClass}Controller

@return string
960930
public function getControllerName()
    {
        //default controller for SiteTree objects
        $controller = CatalogueController::class;

        //go through the ancestry for this class looking for
        $ancestry = ClassInfo::ancestry($this->owner->ClassName);

        // loop over the array going from the deepest descendant (ie: the current class) to SiteTree
        while ($class = array_pop($ancestry)) {
            //we don't need to go any deeper than the SiteTree class
            if ($class == CatalogueProduct::class || $class == CatalogueCategory::class) {
                break;
            }
            
            // If we have a class of "{$ClassName}Controller" then we found our controller
            if (class_exists($candidate = sprintf('%sController', $class))) {
                $controller = $candidate;
                break;
            } elseif (class_exists($candidate = sprintf('%s_Controller', $class))) {
                // Support the legacy underscored filename, but raise a deprecation notice
                Deprecation::notice(
                    '5.0',
                    'Underscored controller class names are deprecated. Use "MyController" instead of "My_Controller".',
                    Deprecation::SCOPE_GLOBAL
                );
                $controller = $candidate;
                break;
            }
        }

        return $controller;
    }
927965
protected function getTableNameForClass(string $modelClass): string
    {
        assert(
            $this->getModelSchemas()->hasClass($modelClass),
            "Class `$modelClass` is not found in model Schemas."
        );

        $tableName = $this->getModelSchemas()->getTable($modelClass);

        return $tableName;
    }
468922
public function getController()
    {
        if (is_null($this->_controller)) {
            $controller = $this->getConfiguration()
                ->get('router.controller', 'pages');
            if (isset($this->_params['controller'])) {
                $controller = $this->_params['controller'];
            }
            $this->_controllerName = $controller;
            $this->_controller = trim(
                "{$this->namespace}\\". ucfirst($controller),
                '\\'
            );
        }
        return $this->_controller;
    }
952631
public function getModelNameHtmlAttribute()
    {
        $class = Decoy::controllerForModel($this->model);

        // There is not a controller for the model
        if (!$class || !class_exists($class)) {
            return sprintf('<b><a href="%s">%s</a></b>',
            $this->filterUrl(['model' => $this->model]),
            preg_replace('#(?<!\ )[A-Z]#', ' $0', $this->model));
        }

        // There is a corresponding controller class
        $controller = new $class;
        return sprintf('<b class="js-tooltip" title="%s"><a href="%s">%s</a></b>',
            htmlentities($controller->description()),
            $this->filterUrl(['model' => $this->model]),
            Str::singular($controller->title()));
    }
1135791
protected function getFormClassNameFromControllerAction()
    {
        return $this->controllerService->getFormClassNameFromControllerAction(
            $this->getControllerName(),
            $this->getControllerActionName(),
            $this->getFormObjectName()
        );
    }
228917
public function detectControllerName()
    {
        $pattern = '#/'.$this->controllerNameRegex().'#i';
        if (!preg_match($pattern, $this->path, $matches)) {
            return false;
        }

        return $matches[1];
    }
999510
public function getControllerName(Model $model) {
		$modelNamePlural = $this->getModelNamePlural($model, false);
		$controllerName = mb_strtolower(Inflector::underscore($modelNamePlural));

		return $controllerName;
	}
587052
protected function getControllerKey()
    {
        $actualClass = get_class($this);
        $controllerKey = \OxidEsales\Eshop\Core\Registry::getControllerClassNameResolver()->getIdByClassName($actualClass);
        if (is_null($controllerKey)) {
            //we might not have found a class key because class is a module chain extended class
            $controllerKey = \OxidEsales\Eshop\Core\Registry::getControllerClassNameResolver()->getIdByClassName($this->getShopParentClass());
        }
        return $controllerKey;
    }
300553
public function getControllerName()
    {
        if (null == $this->controllerName) {
            $this->controllerName = ucfirst($this->input->getArgument('controllerName'));
        }
        return $this->controllerName;
    }
1327657
public static function findControllerID()
    {
        if (empty($_REQUEST[self::KEY_ID])
            || empty($_SESSION[sprintf(self::KEY_CONTAINER, $_REQUEST[self::KEY_ID])])
        ) {
            return null;
        } else {
            return $_REQUEST[self::KEY_ID];
        }
    }
1187933
protected function _getController()
    {
        if (!$this->_controller instanceof KControllerInterface) {
            $this->_controller = $this->getObject($this->_controller);
        }

        return $this->_controller;
    }
573161
public function getControllerName()
    {
        if (empty($this->controller_name)) {
            $controller_class = get_class($this);

            if (($pos = strrpos($controller_class, '\\')) !== false) {
                $this->controller_name = substr($controller_class, $pos + 1);
            } else {
                $this->controller_name = $controller_class;
            }
        }

        return $this->controller_name;
    }
549300
public static function getInstance()
    {
        $controller = get_called_class();

        if (! isset(self::$instance[$controller])) {
            self::$instance[$controller] = new $controller;
        }

        if (is_null(self::$instance[$controller]->view)) {
            self::getViewInstance(self::$instance[$controller]);
        }

        self::getModelInstance(self::$instance[$controller], $controller);

        return self::$instance[$controller];
    }
1277313
protected function getControllerPrefix(ReflectionClass $controller)
    {
        preg_match("~\@prefix\s([a-zA-Z\\\_]+)~i", (string) $controller->getDocComment(), $prefix);
        return isset($prefix[1]) ? $prefix[1] : str_replace("controller", "", strtolower($controller->getShortName()));
    }
1325359
public function getControllerName()
    {
        $controllerObjectName = $this->getControllerObjectName();
        if ($controllerObjectName !== '') {

            // Extract the controller name from the controller object name to assure that the case is correct.
            // Note: Controller name can also contain sub structure like "Foo\Bar\Baz"
            return substr($controllerObjectName, -(strlen($this->controllerName) + 10), - 10);
        } else {
            return $this->controllerName;
        }
    }
302679
protected function getShortNameForController($name): string
    {
        return camel_case(str_replace_last($this->server->postfix, '', class_basename($name)));
    }
392840
public function getRequestedControllerName()
    {
        if (isset($this->_routingInfo['requested_controller'])) {
            return $this->_routingInfo['requested_controller'];
        }
        if (($this->_rewritedPathInfo !== null) && isset($this->_rewritedPathInfo[1])) {
            return $this->_rewritedPathInfo[1];
        }
        return $this->getControllerName();
    }