get path of config files.

@param $param(string) : file name
322382
protected static function getPath($param)
    {
        $path = (is_null(Application::$root) ? "config/$param.php" : Application::$root."config/$param.php");
        //
        return Bus::need((is_null(Application::$root) ? "config/$param.php" : Application::$root."config/$param.php"));
    }
730270
public function getConfigVariableList(array $param)
    {

        if (!$param || !is_array($param)) {
            return null;
        }

        $list = [];

        foreach ($param as $key) {
            $list[$key] = $this->setting[$key];
        }

        return $list;
    }
355048
final protected function getValueFromParam(string $param)
  {
    if (preg_match(self::$regEx['match'], $param)) {
      $arg = preg_filter(self::$regEx['filter'], '', $param);
      if (preg_match(self::$regEx['config'], $arg)) {
        return $this->getValueFromConfig($arg);
      } elseif (preg_match(self::$regEx['array'], $arg)) {
        return $this->getValueFromArray($arg);
      } else {
        return Fixtures::get($arg);
      }
    } else {
      return $param;
    }
  }
488041
public function computePath($params) {
    $route = $this->getPath();

    if (!preg_match_all(
      '~' . self::VARIABLE_REGEX . '~x', $route, $matches,
      PREG_OFFSET_CAPTURE | PREG_SET_ORDER
    )) {
      return $route;
    }

    $offset = 0;
    $url = '';

    /** @var string[] $matches */
    foreach ($matches as $set) {
      if ($set[0][1] > $offset) {
        $url .= substr($route, $offset, $set[0][1] - $offset);
      }
      if(isset($params[$set[1][0]])) {
        $url .= $params[$set[1][0]];
      } else {
        throw new \InvalidArgumentException(sprintf('No value supplied for "%s"', $set[1][0]));
      }
      $offset = $set[0][1] + strlen($set[0][0]);
    }
    if ($offset !== strlen($route)) {
      $url .= substr($route, $offset);
    }

    return $url;
  }
104959
def get_conf_path(filename=None):
    """"""
    conf_dir = osp.join(get_home_dir(), '.condamanager')

    if not osp.isdir(conf_dir):
        os.mkdir(conf_dir)

    if filename is None:
        return conf_dir
    else:
        return osp.join(conf_dir, filename)
18801
protected function getPathByOptionOrConfig($option, $configName)
    {
        if ($path = $this->option($option)) return $path;

        return Config::get("generators::config.{$configName}");
    }
896767
public static function route($param = '')
    {
        $param = parent::route($param);

        switch ($param) {
            case 'types':
                return static::URL . '/' . $param;
        }

        // Otherwise, we may have been sent a longer path, e.g. types/manage/$type/fields
        if (0 == strpos($param, 'types/manage')) {
            // @todo Better checking on these paths.
            return static::URL . '/' . $param;
        }
        throw new RuntimeException('Invalid route parameter passed to AdminStructure PageObject.');
    }
781177
public function hasParam($param)
	{
		$param = (string)$this->params[$param];
		
		return strlen($param) > 0 ? true : false;
	}
1171288
public function getParam($param)
    {
        if (isset($this->_parentConfig))
            return ($this->_parentConfig->getParam($param));
        return (isset($this->_params[$param]) ? $this->_params[$param] : null);
    }
627862
public function getConfig($destination, $param)
    {
        if (isset($this->destinations[$destination])) {
            return $this->destinations[$destination]->getConfig($param);
        }

        return false;
    }
1242381
def get_default_config_file_path(init_filename=None):
    """"""
    prm_dir = get_package_prm_dir()
    if not init_filename:
        init_filename = DEFAULT_FILENAME
    src = os.path.join(prm_dir, init_filename)
    return src
1273020
public static function getParameter($param)
    {
        $lexer = new Lexer('(' . $param . ')');

        // A dummy parser is used for error reporting.
        $param = ParameterDefinition::parse(new Parser(), $lexer->list);

        if (empty($param[0])) {
            return [
                '',
                '',
                '',
                '',
                '',
            ];
        }

        $param = $param[0];

        $options = [];
        foreach ($param->type->options->options as $opt) {
            $options[] = is_string($opt) ? $opt : $opt['value'];
        }

        return [
            empty($param->inOut) ? '' : $param->inOut,
            $param->name,
            $param->type->name,
            implode(',', $param->type->parameters),
            implode(' ', $options),
        ];
    }
697894
public function route( $param = null ) {
		$route = call_user_func( $this->get_route_resolver() );

		if ( is_null( $route ) || is_null( $param ) ) {
			return $route;
		}

		return array_key_exists( $param, $route[2] ) ? $route[2][ $param ] : null;
	}
409714
public function load($param = null)
    {
        try {
            if (empty($param['file'])) {
                throw new ConfigException(_('No config file was give please, the parameter '), 0, 1, __METHOD__, __LINE__);
            }
            $this->configFile = (string)$param['file'];

            if (isset($param['process-sections'])) {
                $this->processSections = (bool)$param['process-sections'];
            }
            if (isset($param['scanner-mode'])) {
                $this->scannerMode = (int)$param['scanner-mode'];
            }

            $data = parse_ini_file($this->configFile, $this->processSections, $this->scannerMode);

            $this->mainNode = new Node(null, IConfig::MAIN_NODE_KEY, 'main node');
            foreach ($data as $key => $group) {
                if (!is_array($group)) {
                    $newNode = new Node($this->mainNode, $key, $group);
                    $this->mainNode->addChild($newNode);
                    continue;
                }

                $newNode = new Node($this->mainNode, $key, $key);

                foreach ($group as $name => $value) {
                    $childNode = new Node($newNode, $name, $value);
                    $newNode->addChild($childNode);
                }
                $this->mainNode->addChild($newNode);
            }
        } catch (ConfigException $e) {
            throw $e;
        }
    }
342698
final protected function getValueFromConfig(string $param)
  {
    $value = null;
    $config = self::$suiteConfig;

    preg_match_all(self::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
    foreach ($args[1] as $arg) {
      if (array_key_exists($arg, $config)) {
        $value = $config[$arg];
        if (is_array($value)) {
          $config = $value;
        } else {
          break;
        }
      }
    }
    return $value;
  }
127387
protected static function getValue($param)
    {
        $data = explode(':', $param);

        $result = ['rule' => trim($data[0])];

        $result['value'] = count($data) > 1 ? $data[1] : null;

        return $result;
    }
1114970
protected function parseParam($param, string $name)
    {
        if (is_iterable($param)) {
            foreach ($param as $key => $value) {
                $param[$key] = $this->parseParam($value, $name);
            }

            return $param;
        }

        if (is_string($param)) {
            $param = $this->config->getEnv($param);

            if (preg_match('#^\{\{([^{}]+)\}\}$#', $param, $matches)) {
                return '{'.$matches[1].'}';
            }
            if (preg_match('#^\{([^{}]+)\}$#', $param, $matches)) {
                return $this->traverseTree($name, $matches[1]);
            }

            return $param;
        }

        return $param;
    }