Get names for all values/factories

@access private
@internal For unit testing only, do not use
@return string[]
429231
public function getNames() {
		$names = [];

		$refl = new ReflectionObject($this);
		foreach ($refl->getProperties(ReflectionProperty::IS_PUBLIC) as $prop) {
			$names[] = $prop->name;
		}
		foreach (array_keys($this->factories_) as $name) {
			$names[] = $name;
		}

		sort($names);
		return $names;
	}
256029
public function fetchScriptSettings()
    {
        $data = [];

        $scriptSettings = $this->factory->getConnection()->getModeScriptSettings();

        /**
         * @var string $i
         */
        $i = 1;
        foreach ($scriptSettings as $name => $value) {
            $data[] = [
                'index' => $i++,
                'name' => $name,
                'value' => $value,
            ];
        }

        return $data;
    }
878628
public function getChartNames()
    {
        $chartNames = array();
        foreach($this->_chartCollection as $chart) {
            $chartNames[] = $chart->getName();
        }
        return $chartNames;
    }
1198532
public function getFactoryNamespace()
    {
        $result = $this->_factoryNamespace;

        if ($result && strpos($result, '\\') !== 0) {
            $result = '\\' . $result;
        }

        return $result;
    }
387046
private function get_all_plugin_names() {
		$names = array();
		foreach ( get_plugins() as $file => $details ) {
			$names[] = Utils\get_plugin_name( $file );
		}

		return $names;
	}
573048
private function getFactoryInfo($factoryName)
    {
        if (!$this->hasFactory($factoryName)) {
            throw new NotRegisteredException($this->translate(
                'Factory "{name}" is not registered in toolbox "{toolbox}".',
                ['name' => $factoryName, 'toolbox' => get_class($this)]
            ));
        }

        list ($factoryClassName, $contracts) = $this->_registeredFactories[$factoryName];

        $options = $this->getFactoryConfig($factoryName);

        return [$factoryClassName, $contracts, $options];
    }
914515
public function getFlattenValidators()
    {
        if (!$this->exists) {
            return [];
        }

        $validators = $this->validators;
        $return     = [];
        if (!empty($validators)) {
            foreach ($validators as $validator) {
                $return[$validator->validator_id] = $validator->value;
            }
        }
        return $return;
    }
559152
public function getModuleNames()
    {
        $data = [];
        foreach (Yii::$app->getFrontendModules() as $k => $f) {
            $data[] = ['value' => $k, 'label' => $k];
        }
        return $data;
    }
1328868
function getNamedArray()
    {
        if ( isset( self::$injectedSettings[$this->FileName] ) )
        {
            return array_merge(
                $this->BlockValues,
                self::$injectedSettings[$this->FileName]
            );
        }
        return $this->BlockValues;
    }
288855
public function getKeys()
    {
        $keys = array_keys($this->cache) + array_keys($this->factories);
        return array_unique($keys);
    }
1177934
public function getAllClassNames()
    {
        if (is_array($this->classNames)) {
            return $this->classNames;
        }

        $this->classNames = array_merge(
            $this->reflectionService->getClassNamesByAnnotation(Flow\ValueObject::class),
            $this->reflectionService->getClassNamesByAnnotation(Flow\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\MappedSuperclass::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Embeddable::class)
        );
        $this->classNames = array_filter($this->classNames,
            function ($className) {
                return !interface_exists($className, false)
                        && strpos($className, Compiler::ORIGINAL_CLASSNAME_SUFFIX) === false;
            }
        );

        return $this->classNames;
    }
399639
public static function getEventNames()
    {
        $names = [];
        $reflection = new \ReflectionClass(self::class);
        foreach ($reflection->getConstants() as $constant => $value) {
            if ('REPEATED_' === substr($constant, 0, 9)) {
                $names[] = $value;
            }
        }

        return $names;
    }
548799
public static final function values() {
			if (!static::isDone())
				static::autoload();

			$key = get_called_class();

			if (array_key_exists($key, self::$types))
				return self::$types[$key];

			return array();
		}
388243
public function getViewHelperConfig()
    {
        return [
            'factories' => [
                View\Helper\Params::class => View\Helper\Factory\ParamsFactory::class,
                View\Helper\Config::class => View\Helper\Factory\ConfigFactory::class,
                View\Helper\Env::class => View\Helper\Factory\EnvFactory::class,
                View\Helper\CdnVersion::class => View\Helper\Factory\EnvFactory::class,
                View\Helper\FormLocalMessage::class => InvokableFactory::class,
                //\Zend\Form\View\Helper\FormElementErrors::class => View\Helper\Factory\FormElementErrorsFactory::class,
            ],
            'aliases' => [
                'helperParams' => View\Helper\Params::class,
                'helperConfig' => View\Helper\Config::class,
                'helperEnv' => View\Helper\Env::class,
                'helperCdnVersion' => View\Helper\CdnVersion::class,
                'formLocalMessage' => View\Helper\FormLocalMessage::class,
                'helperFormLocalMessage' => View\Helper\FormLocalMessage::class,
            ],
        ];
    }
587260
public function getInterfaceNames()
    {
        $interfaces = array();

        if ($this->node instanceof Node\Stmt\Class_) {
            foreach ($this->node->implements as $interface) {
                $interfaces[] = (string) $interface;
            }
        }

        return $interfaces;
    }
55294
public function getValues()
    {
        $values = [];
        foreach ($this->findScenario() as $name) {
            $values[$name] = $this->$name;
        }
        return $values;
    }
149150
public function getVariableRefs()
	{
		$variableRefs = array();

		if ( isset( $this->testXPath2Expression ) )
		{
			$variableRefs = array_merge( $variableRefs, $this->testXPath2Expression->getParameterQNames() );
		}

		return $variableRefs;
	}