@param $config_name String

@return array
553432
protected function getYamlConfig($config_name)
    {
        if ($this->configStorage->exists($config_name)) {
            $configuration = $this->configStorage->read($config_name);
            $configurationEncoded = Yaml::encode($configuration);
        }

        return $configurationEncoded;
    }
372272
function get_var_names($file_name, $section = NULL)
	{
		if (empty($file_name)) {
			$this->_trigger_error_msg('Empty config file name');
			return;
		} else if (!isset($this->_config_data[$file_name])) {
			$this->_trigger_error_msg("Unknown config file '$file_name'");
			return;
		}

		if (empty($section))
		return array_keys($this->_config_data[$file_name]["vars"]);
		else
		return array_keys($this->_config_data[$file_name]["sections"][$section]["vars"]);
	}
149916
private function massageConfig(array $config, string $configPath) : array
    {
        if (!isset($config['installed_paths'])) {
            return $config;
        }

        $config['installed_paths'] = implode(',', array_map(function ($path) use ($configPath) {
            return dirname($configPath) . '/' . $path;
        }, explode(',', $config['installed_paths'])));

        return $config;
    }
498666
public function getConfigParam($name)
    {
        $result = null;
        $config = $this->getConfiguration();
        $parts  = explode('.', $name);
        foreach ($parts as $key) {
            if (isset($config[$key])) {
                $result = $config = $config[$key];
            } else {
                $result = null;
                break;
            }
        }
        return $result;
    }
79101
private function readConfigFile(string $configFilename): array
  {
    $settings = parse_ini_file($configFilename, true);

    $this->constantsFilename = self::getSetting($settings, false, 'constants', 'columns');
    $this->className         = self::getSetting($settings, false, 'constants', 'class');

    return $settings;
  }
1041681
public function getCleanedFieldAsArray(string $field_name): array
    {
        if (empty($this->initial_data[$field_name])) {
            return [];
        }

        // Usually string "false" from javascript interpreted as true, but it must be false
        if (!\is_array($this->initial_data[$field_name])) {
            return [];
        }

        return (array)$this->initial_data[$field_name];
    }
338226
protected function getConfig($name)
    {
        $config = $this->app['config']['picture'];
        $driverConfig = isset($config['disks'][$name]) ? $config['disks'][$name] : [];
        if (!isset($driverConfig['sizeList'])) {
            $driverConfig['sizeList'] = $config['sizeList'];
        }
        if (!isset($driverConfig['quality'])) {
            $driverConfig['quality'] = $config['quality'];
        }
        return $driverConfig;
    }
682534
public function getHeaderForRender(string $report_name, string $header_name) : array {
		$columns = $this->data[$report_name]['header'][$header_name];
		foreach ($columns as $k => $v) {
			if ($k == 'blank' || empty($v['label_name'])) continue;
			$columns[$k]['as_header'] = true;
			$columns[$k]['value'] = $v['label_name'];
		}
		return $columns;
	}
401360
private function get_option_name( $option_name_list ) {

		$option_name_list = (array) $option_name_list;

		foreach ( $option_name_list as $this_option_name ) {
			if ( null !== get_option( $this_option_name, null ) ) {
				return $this_option_name;
			}
		}

		return null;

	}
669996
protected static function _defaultConfig($name)
    {
        $defaults = [
            'php' => [
                'cookie' => 'CAKEPHP',
                'ini' => [
                    'session.use_trans_sid' => 0,
                ]
            ],
            'cake' => [
                'cookie' => 'CAKEPHP',
                'ini' => [
                    'session.use_trans_sid' => 0,
                    'session.serialize_handler' => 'php',
                    'session.use_cookies' => 1,
                    'session.save_path' => TMP . 'sessions',
                    'session.save_handler' => 'files'
                ]
            ],
            'cache' => [
                'cookie' => 'CAKEPHP',
                'ini' => [
                    'session.use_trans_sid' => 0,
                    'session.use_cookies' => 1,
                    'session.save_handler' => 'user',
                ],
                'handler' => [
                    'engine' => 'CacheSession',
                    'config' => 'default'
                ]
            ],
            'database' => [
                'cookie' => 'CAKEPHP',
                'ini' => [
                    'session.use_trans_sid' => 0,
                    'session.use_cookies' => 1,
                    'session.save_handler' => 'user',
                    'session.serialize_handler' => 'php',
                ],
                'handler' => [
                    'engine' => 'DatabaseSession'
                ]
            ]
        ];

        if (isset($defaults[$name])) {
            return $defaults[$name];
        }

        return false;
    }
435590
public function getFieldValues(string $field_name)
    {
        try {
            $field = [];
            $result = $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
            if (array_key_exists($field_name, $result[0])) {
                foreach ($result as $row) {
                    $field[] = $row[$field_name];
                }
            } else {
                throw new \Exception("Field '$field_name' is not present in the current result set.\n");
            }
            return $field;
        } catch (\PDOException $e) {
            die('Error: ' . $e->getMessage());
        } catch (\Exception $e) {
            die("Error: " . $e->getMessage());
        }
    }
49566
private static function get_fields_by_config( $config_id ) {
		$fields = [];
		foreach ( self::$fields as $field ) {
			if ( ( isset( $field['kirki_config'] ) && $config_id === $field['kirki_config'] ) || ( 'global' === $config_id || ! $config_id ) && ( 'global' === $field['kirki_config'] || ! $field['kirki_config'] ) ) {
				$fields[] = $field;
			}
		}
		return $fields;
	}
1153907
public function getCommand($name, Config $config)
    {
        if (!$config->hasItem('commands', $name)) {
            if (!$config->hasItem('commands', '_'.$name)) {
                $config->checkItem('commands', $name);
            }
            $name = '_'.$name;
        }

        return $config->getItem('commands', $name);
    }
432488
public static function getConfig($key = null, $conn_name = self::DEFAULT_CONNECTION) {
        
        if( $key && is_null($conn_name) ) {
            
            //get key's value for each connection
            $conn_names = array_keys(static::$_config);
            $val_of_key_4_each_conn_name = array_column(static::$_config, $key);
            
            return array_combine($conn_names, $val_of_key_4_each_conn_name);
            
        } else if ( $key && !is_null($conn_name) && strlen($conn_name) > 0 ) {
            
            //get key's value for the specified connection
            return static::$_config[$conn_name][$key];
            
        } else if( !$key && is_null($conn_name) ) {
            
            //get all config values for all connections
            return static::$_config;
            
        } else {
            
            //get all config values for the specified connection
            return static::$_config[$conn_name];
        }
    }
1061631
public function getConfigItems($config) {
		$config = strtolower($config);
		return isset($this->config[$config]) ? $this->config[$config] : array();
	}
1169501
public function getArrayOf(string $name) : array
    {
        $array = $this->content->hasArrayOf($name) ? $this->content->getArrayOf($name) : [];

        foreach ($array as $key => $contentGroup) {
            $array[$key] = new self($this->config, $contentGroup);
        }

        return $array;
    }
1362883
public static function config_get_configuration_array($data) {
        $return = array(
            'server' => $data->server,
            'database' => $data->database,
            'extendedmode' => (!empty($data->extendedmode))
        );
        if (!empty($data->username)) {
            $return['username'] = $data->username;
        }
        if (!empty($data->password)) {
            $return['password'] = $data->password;
        }
        if (!empty($data->replicaset)) {
            $return['replicaset'] = $data->replicaset;
        }
        if (!empty($data->usesafe)) {
            $return['usesafe'] = true;
            if (!empty($data->usesafevalue)) {
                $return['usesafe'] = (int)$data->usesafevalue;
                $return['usesafevalue'] = $return['usesafe'];
            }
        }
        return $return;
    }