Get the full array of overridden names to pass to PostTypes\Taxonomy.

@since 1.0.0

@return array All names.
161529
private function get_names()
    {
        $names = [
            'name' => $this->get_name(),
        ];

        if ($this->plural !== null) {
            $names['plural'] = $this->plural;
        }

        if ($this->singular !== null) {
            $names['singular'] = $this->singular;
        }

        if ($this->slug !== null) {
            $names['slug'] = $this->slug;
        }

        return $names;
    }
208659
@Override
    public String[] getDeclaredSupertypeNames() {
        List<String> supertypeNames = new ArrayList<String>(declaredSupertypes.size());

        for (JcrNodeType declaredSupertype : declaredSupertypes) {
            supertypeNames.add(declaredSupertype.getName());
        }

        // Always have to make a copy to prevent changes ...
        return supertypeNames.toArray(new String[supertypeNames.size()]);
    }
387046
private function get_all_plugin_names() {
		$names = array();
		foreach ( get_plugins() as $file => $details ) {
			$names[] = Utils\get_plugin_name( $file );
		}

		return $names;
	}
968632
public function getTaxonomyKeys()
    {
        $taxonomies = $this->getTaxonomies();
        if (!Arr::iterable($taxonomies)) {
            return array();
        }

        $out = array();
        foreach ($taxonomies as $k => $taxonomy) {
            $taxonomy = $this->getTaxonomy($k);
            $out[] = $this->getTaxonomyKey($k, $taxonomy);
        }
        return $out;
    }
1084461
public function getChildrenNames()
    {
        if ($this->inheritanceColumn === null || !$this->inheritanceColumn->isEnumeratedClasses()) {
            return null;
        }
        $children = $this->inheritanceColumn->getChildren();
        $names = array();
        for ($i = 0, $size = count($children); $i < $size; $i++) {
            $names[] = get_class($children[$i]);
        }

        return $names;
    }
1152595
public function getSubClassNames()
    {
        $classes = array();
        $killAncestors = array();
        // make it easier to unset values
        foreach(ClassInfo::subclassesFor($this->ClassName) as $class) {
            $classes[$class] = $class;
        }

        unset(
            $classes['PlaceableObject_Preset'],
            $classes['BlockObject_Preset'],
            $classes['RegionObject_Preset']
        );

        // figure out if there are any classes we don't want to appear
        foreach($classes as $class) {
            $instance = singleton($class);

            if($instance instanceof HiddenClass) {
                unset($classes[$class]);
                continue;
            };

            // apply Translatable name
            $classes[$class] = $instance->i18n_singular_name();

            // do any of the progeny want to hide an ancestor?
            if($ancestor_to_hide = $instance->stat('hide_ancestor')) {
                // note for killing later
                $killAncestors[] = $ancestor_to_hide;
            }
        }

        // If any of the descendents don't want any of the elders to show up,
        // cruelly render the elders surplus to requirements
        if($killAncestors) {
            $killAncestors = array_unique($killAncestors);
            foreach($killAncestors as $mark) {
                unset($classes[$mark]);
            }
        }

        return $classes;
    }
964936
public function getAll()
    {
        $all = array();

        foreach ($this->getNames() as $name) {
            $all[$name] = $this->get($name);
        }

        return $all;
    }
279279
public function getNames()
    {
        $result = array();

        foreach ($this->getBreadcrumbs() as $breadcrumb) {
            array_push($result, $breadcrumb->getName());
        }

        return $result;
    }
224425
public function getNodeNames()
    {
        $data = $this->getState();
        $nodeNames = [];
        foreach ($data['nodes'] as $node) {
            $nodeNames[] = $node['name'];
        }

        return $nodeNames;
    }
157029
protected function getServiceNames()
    {
        $names = [];

        foreach ($this->getServices() as $name => $info) {
            if (!isset($info['type'])) {
                continue;
            }
            $names[$name] = $info['type'];
        }

        return $names;
    }
981824
public function getAvailableOverrides()
    {
        $path   = $this->getPath();
        $suffix = $this->getSuffix();

        $glob   = "{$path}/*{$suffix}";
        $result = [];
        foreach (glob($glob) as $file) {
            $identifier          = basename($file, $suffix);
            $result[$identifier] = $file;
        }

        return $result;
    }
1083782
public function getAllElements()
	{
		if ( $this->context->isExtensionTaxonomy() )
		{
			$prefix = $this->getPrefix();
			return array_map( function( $item ) use ( $prefix ) { $item['prefix'] = $prefix; return $item; }, $this->elementIndex );
		}

		$result = array();
		foreach ( $this->context->importedSchemas as $namespace => $taxonomy )
		{
			$elements = $taxonomy->getElements();
			if ( ! $elements ) continue; // Don't attempt to merge if there are no element and it take time
			$prefix = $taxonomy->getPrefix();
			$elements = array_map( function( $item ) use ( $prefix ) { $item['prefix'] = $prefix; return $item; }, $elements );
			$result = array_merge( $result, $elements );
		}
		return $result;
	}
61592
protected function getAllBaseNames()
    {
        $pluggables = [];

        $path = $this->getPath();

        if (!is_dir($path)) {
            return $pluggables;
        }

        $folders = $this->files->directories($path);

        foreach ($folders as $plug) {
            $pluggables[] = basename($plug);
        }

        return $pluggables;
    }
22733
public function getFieldDatabaseNameArray()
    {
        $fields = [];
        foreach ($this->fields as $field) {
            $fields[] = $field->toSelectString();
        }
        return $fields;
    }
444704
public function getList()
    {
        if ($this->modelClass === TaxonomyTerm::class) {
            $list = parent::getList();
            return $list->filter('ParentID', '0');
        }
        return parent::getList();
    }
511809
public function getAllClassNames(): array
    {
        $auditEntityRepository = $this->getAuditObjectManager()
            ->getRepository(Entity\AuditEntity::class);

        $classNames = [];
        foreach ($this->getEntityConfigCollection() as $className => $config) {
            $classNames[] = $auditEntityRepository->generateClassName($className);
        }

        return $classNames;
    }
735962
public function getAllBlockNames()
    {
        $ret = [ ];
        try {
            $result = $this->getSoapClient()->GetBlockNames();
        } catch ( SoapException $ex ) {
            throw new StatusException('Error while getting the list of all blocks in the active template' , $ex);
        }
        if ( isset($result->GetBlockNamesResult->string) ) {
            if ( is_array($result->GetBlockNamesResult->string) ) {
                $ret = $result->GetBlockNamesResult->string;
            } else {
                $ret[] = $result->GetBlockNamesResult->string;
            }
        }

        return $ret;
    }