retrieves a configuration value
returns false if not found

@param  string $key
@return mixed
484975
public function getConfig($key)
    {
        if (! $this->getServiceLocator()->has($this->getId().'/'.$key)) {
            return false;
        }

        try{
            $config =  $this->getServiceLocator()->get($this->getId().'/'.$key);
            if ($config instanceof ConfigurationService) {
                $config = $config->getConfig();
            }
        } catch(ServiceNotFoundException $e){
            $config = false;
        }
        return $config;
    }
1148391
public function get($key)
    {
        $ret = $this->traverseTree($key);
        if(!is_scalar($ret))
        {
            throw new UnexpectedValueException("The {$key} configuration value is not scalar");
        }
        return $ret;
    }
821646
public function get($key)
    {
        return isset($this->vars[$key]) ? $this->vars[$key] : false;
    }
1109165
public function getConfig($key = null) 
    {	
    	if($key!=null && isset($this->_config[$key])) { 
    		
    		return $this->_config[$key];
    	
    	} elseif($key == null) {
    		
            return $this->_config;
    	}

        return null;
    }
1171240
protected function _getConfig($key = null) {
		$language = Configure::read('Config.language');
		$key = (string)$key;

		if ($key === 'Language') {
			if (empty($language)) {
				return null;
			}

			$configs = $language;
		} else {
			$configPath = $this->_modelConfigSettingsApp->getNameConfigKey();
			if (!empty($key)) {
				$configPath .= '.' . $key;
			}

			$configs = Configure::read($configPath);
			if ($configs === null) {
				return null;
			}

			if (empty($key)) {
				$configs['Language'] = $language;
			}
		}

		if (!empty($key)) {
			$configs = [$key => $configs];
		}

		$listSerializedFields = $this->_modelConfigSettingsApp->getListSerializeFields();
		$result = [];
		foreach ($configs as $configName => $configValue) {
			switch ($configName) {
				case 'EmailSmtppassword':
					if (!empty($configValue)) {
						$result[$this->alias][$configName] = Security::decrypt(base64_decode($configValue), Configure::read('Security.key'));
					} else {
						$result[$this->alias][$configName] = $configValue;
					}
					break;
				default:
					if (in_array($configName, $listSerializedFields) && !empty($configValue)) {
						$configValue = unserialize($configValue);
					}
					$result[$this->alias][$configName] = $configValue;
			}
		}

		if (!empty($key)) {
			return Hash::get($result, $this->alias . '.' . $key);
		}

		if (empty($result)) {
			return null;
		}

		return $result;
	}
212543
public function getConfiguration($key = null) {
        if (!$key) {
            return $this->_configuration;
        }
        if (!array_key_exists($key, $this->_configuration)) {
            throw new Exception("'$key' is not a valid configuration key.");
        }
        return $this->_configuration[$key];
    }
1322257
public function get(string $key)
    {
        $hash =  self::findFirst([
            'conditions' => "{$this->settingsKey} = ?0 and key = ?1",
            'bind' => [$this->getSettingsKey(), $key]
        ]);

        if ($hash) {
            return $hash->value;
        }

        return null;
    }
753402
public function getConfigurationValue($key, $default = null)
    {
        if (is_array($this->configuration) && array_key_exists($key, $this->configuration)) {
            return $this->configuration[$key];
        }

        return $default;
    }
1086027
public function get($key)
    {
        $this->load();
        $value = NestedArrayUtil::getNestedArrayValue($this->state, explode('.', $key), $exists);

        return $exists ? $value : false;
    }
80125
public function get($key)
    {
        $setting = $this->getSettingOrFail($key);

        $value = $this->backend->getSetting($key);

        return  is_null($value) ? $setting->default() : $value;
    }
744694
protected function config(string $key)
    {
        $config = json_decode($this->header('config'), true);
        $definition = explode('.', $key);
        $item = isset($config[$definition[0]]) ? $config[$definition[0]] : null;

        $numberOfDefinitions = count($definition);

        for ($i = 1; $i < $numberOfDefinitions; ++$i) {
            $item = isset($item[$definition[$i]]) ? $item[$definition[$i]] : null;
        }

        return $item;
    }
658512
protected function iterateConfig(string $key)
    {
        $result = $this->config;

        foreach (explode('.', $key) as $p) {
            if (!isset($result[$p])) {
                return null;
            }

            $result = $result[$p];
        }

        return $result;
    }
704051
public function get(string $key)
    {
        if (empty($key) || !$this->isEnable()) {
            return false;
        }

        $value = $this->read();
        if (!is_array($value) || !isset($value[$key])) {
            return false;
        }

        return $value[$key];
    }
186531
public function getConfigVariable(string $key)
    {
        if ($key === '' || $key === null) {
            return null;
        }

        if (!isset($this->setting[$key])) {
            return null;
        }

        return $this->setting[$key];
    }
737970
public function get($key)
    {
        $value = $this->arguments->get($key);

        if (null === $value) {
            $value = $this->configuration->get($key);

            if (null === $value) {
                $value = $this->defaults->get($key);
            }
        }

        return $value;
    }
123558
public function get($section, $key){
		if(!isset($this->configValues[$section][$key])){
			return false;
		}
		return $this->configValues[$section][$key];
	}
742966
public function get($key = '')
    {
        if ( !isset($_SESSION) ) {
            return false;
        }

        if ($key == '') {
            return $_SESSION;
        } elseif (array_key_exists($key, $_SESSION)) {
            return $_SESSION[$key];
        } elseif (strpos($key, '.')) {
            $names = explode('.', $key);

            $value = $_SESSION;
            foreach ($names as $v) {
                if (isset($value[$v])) {
                    $value = $value[$v];
                } else {
                    $value = false;
                    break;
                }
            }

            return $value;
        } else {
            return false;
        }
    }