Get the namespace of the repositories classes.

@return string
967646
protected function getNamespace($namespace = null)
    {
        if (!is_null($namespace)) {
            $parts = explode('\\', $namespace);

            array_pop($parts);

            return join('\\', $parts);
        }

        return $this->getAppNamespace() . $this->namespace;
    }
819871
public function getClassName()
    {
        $classNames = array();
        foreach ($this->_repositories as $repository) {
            $classNames[] = $repository->getClassName();
        }
        return $classNames;
    }
970088
private function getCommandNamespace()
    {
        $concrete_namespace = $this->getCommandDeclaredNamespace();

        if ($this->hasOption('system-folder')) {

            $concrete_namespace = $concrete_namespace . '\\' . $this->option('system-folder');
        }

        if ($this->hasOption('folder')) {
            
            if ($this->option('folder')) {
                
                $concrete_namespace = $concrete_namespace . '\\' . $this->option('folder'); 
            }
        }

        return $this->sanitizedPath($concrete_namespace);
    }
645995
protected function _repository()
    {
        $source = $this->getSource();
        if ($source === null) {
            list(, $class) = namespaceSplit(get_class($this));
            $source = Inflector::pluralize($class);
        }

        return TableRegistry::getTableLocator()->get($source);
    }
177745
protected function getRootNameSpace()
    {
        if (!$namespace = $this->option('namespace')) {
            list($vendor, $name) = explode('/', $this->package);

            $default = str_replace(['-', '-'], '', Str::title($vendor).'\\'.Str::title($name));

            $namespace = $this->ask('Root namespace', $default);
        }

        return $namespace;
    }
386754
public function getNamespaceName()
    {
        $parts = $this->node->consts[0]->namespacedName->parts;
        array_pop($parts);
        return implode('\\', $parts);
    }
1232083
public function getNamespace()
    {
        if (null === $this->reflected) {
            $this->reflected = new \ReflectionObject($this);
        }

        return $this->reflected->getNamespaceName();
    }
1368006
public function getBundleNamespaceRoot()
    {
        $bundleParts = explode('\\', $this->getNamespace());
        unset($bundleParts[count($bundleParts) - 1]);

        return implode('\\', $bundleParts);
    }
819544
public function getFileNamespace(): string
	{
		if($this->fileNamespace === null)
		{
			$this->fileNamespace = str_replace('/', '-', strtolower($this->packageName));
		}

		return $this->fileNamespace;
	}
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;
    }
1024210
public function getClassesInNamespace(string $namespace)
    {
        $arrOptions = [];

        foreach (get_declared_classes() as $strName) {
            if ($this->container->get('huh.utils.string')->startsWith($strName, $namespace)) {
                $arrOptions[$strName] = $strName;
            }
        }

        asort($arrOptions);

        return $arrOptions;
    }
982959
public function getModuleNamespace()
    {
        if (!$this->module || '\\' == $this->module || '/' == $this->module) {
            return '\app';
        }
        if (isset($this->modules[$this->module]['namespace'])) {
            return $this->modules[$this->module]['namespace'];
        }
        return '\app\modules\\' . $this->module;
    }
240939
public function getRepository()
    {
        $repositoryGenerator = new RepositoryInterfaceGenerator([
            'name' => $this->name,
        ]);

        $repository = $repositoryGenerator->getRootNamespace() . '\\' . $repositoryGenerator->getName();

        return 'use ' . str_replace([
            "\\",
            '/'
        ], '\\', $repository) . 'Repository;';
    }
522488
public function getNamespace()
    {
        if (isset($this->properties[ 'namespace' ])) {
            return $this->properties[ 'namespace' ];
        }

        $dir = $this->getRealPath();
        $dirParts = explode('Widgets' . DIRECTORY_SEPARATOR, $dir);
        $namespace = loader()->getDirNamespace(reset($dirParts)) . 'Widgets\\' . str_replace(['/', DIRECTORY_SEPARATOR],
                '\\', end($dirParts));

        return $namespace;
    }
434836
public function getNamespaces()
    {
        $result = [];
        foreach ($this->registry[NamespaceExtension::class] as $extension) {
            foreach ($extension->getNamespaces() as $prefix => $namespace) {
                $result[$prefix] = $namespace;
            }
        }

        return $result;
    }
474546
public function getNamespace($namespace)
    {
        $classes = [];
        $definitions = $this->classes->extract();

        foreach (array_keys($definitions) as $class) {
            if (strpos($class, $namespace, 0) === 0) {
                $classes[$class] = $this->get($class);
            }
        }

        return $classes;
    }
133292
protected function getModuleNamespace()
    {
        if (null === $this->moduleNamespace) {
            $class                 = get_class($this);
            $this->moduleNamespace = substr($class, 0, strpos($class, '\\'));
        }
        return $this->moduleNamespace;
    }