Get auth method.

@param string $key

@return string|array
556804
public function getAuthMethod($key)
    {
        if (array_has($this->getAuths(), $key)) {
            $method = 'auth'.studly_case(array_get($this->getAuths(), $key));

            return method_exists($this, $method) ? $method : false;
        }

        return false;
    }
102649
public static function getTrustedHeaderName($key)
    {
        if (2 > func_num_args() || func_get_arg(1)) {
            @trigger_error(sprintf('The "%s()" method is deprecated since version 3.3 and will be removed in 4.0. Use the Request::getTrustedHeaderSet() method instead.', __METHOD__), E_USER_DEPRECATED);
        }

        if (!array_key_exists($key, self::$trustedHeaders)) {
            throw new \InvalidArgumentException(sprintf('Unable to get the trusted header name for key "%s".', $key));
        }

        return self::$trustedHeaders[$key];
    }
436925
public static function get($key) {
        if (isset(self::$keyvals) && isset(self::$keyvals[$key])) {
            return self::$keyvals[$key];
        }
        return '';
    }
305182
public function get($key) {
        if (isset($this->_session->{$key})) {
            return $this->_session->{$key};
        }
        return null;
    }
1145722
public function get($key)
    {
        return array_key_exists($key, $this->vars) ? $this->vars[$key] : null;
    }
1215162
public function get_crypto_key($key)
    {
        // Bomb out if the requested key does not exist
        if (!array_key_exists($key, $this->prop) || empty($this->prop[$key])) {
            rcube::raise_error(array(
                'code' => 500, 'type' => 'php',
                'file' => __FILE__, 'line' => __LINE__,
                'message' => "Request for unconfigured crypto key \"$key\""
            ), true, true);
        }

        return $this->prop[$key];
    }
236017
public function getParameter($key)
    {
        return isset($this->params[$key]) ? $this->params[$key] : null;
    }
431735
public function getParam($key)
    {
        /* Passwords may be stored encrypted. */
        switch ($key) {
        case 'password':
            if (isset($this->_params[$key]) &&
                ($this->_params[$key] instanceof Horde_Imap_Client_Base_Password)) {
                return $this->_params[$key]->getPassword();
            }

            // DEPRECATED
            if (!empty($this->_params['_passencrypt'])) {
                try {
                    $secret = new Horde_Secret();
                    return $secret->read($this->_getEncryptKey(), $this->_params['password']);
                } catch (Exception $e) {
                    return null;
                }
            }
            break;
        }

        return isset($this->_params[$key])
            ? $this->_params[$key]
            : null;
    }
16523
private function requestToken(array $key) {
		$s = $this->ss();
		// 2017-06-28
		// «Now that you've acquired an authorization code and have been granted permission by the user,
		// you can redeem the code for an access token to the desired resource,
		// by sending a POST request to the `/token` endpoint.»
		// «Use the authorization code to request an access token»:
		// https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-protocols-oauth-code#use-the-authorization-code-to-request-an-access-token
		$c = df_zf_http($this->urlToken())
			->setHeaders(['accept' => 'application/json'])
			->setMethod(C::POST)
			->setParameterPost($this->pCommon() + $key + ['client_secret' => $s->clientPassword()])
		; /** @var C $c */
		/** @var array(string => mixed) $r */
		$this->validateResponse($r = df_json_decode($c->request()->getBody()));
		return $r;
	}
1233067
public function get(string $key)
    {
        $key = strtolower($key);

        if (empty($this->configuration[$key])) {
            $this->loadConfigFile($key);
        }

        return $this->configuration[$key];
    }
105719
public function parseToken($key = 'access_token')
    {
        if ( $token = $this->getToken() )
        {
            $token_array = json_decode($token, true);

            return $token_array[$key];
        }
    }
113391
private function getHeader($key)
    {
        if (isset($this->requestHeader[$key])) {
            $header = $this->requestHeader[$key]['value'];

            unset($this->requestHeader[$key]);
        } else {
            if ($key === 'host') {
                $header = $this->getHost();
            } elseif ($key === 'accept') {
                $header = '*/*';
            } elseif ($key === 'user-agent') {
                $header = self::$userAgent;
            }
        }

        return $header;
    }
1354071
public function get($key) {
        $key = $this->secureKey($key);
        
        if (isset($_SESSION[$key])) {
            return trim(Text::unlock($_SESSION[$key], $this->sugar()));
        } else {
            return '';
        }
    }
154245
protected function getConditionsFromKey($key)
    {
        if (is_int($key) || ctype_digit($key)) {
            return array(self::MATCH_USER_ID => $key);
        }
        if (strpos($key, '@') !== false) {
            return array(self::MATCH_USER_EMAIL => $key);
        }
        return array(self::MATCH_USER_LOGIN => $key);
    }
906055
protected function getMethod($key)
    {
        switch ($key) {
            case CopyMethod::NAME:
                return new CopyMethod();
            case SymlinkMethod::NAME:
                return new SymlinkMethod();
            case JunctionMethod::NAME:
                return new JunctionMethod();
            case VendorPlugin::METHOD_NONE:
                // 'none' is forced to an empty chain
                return new ChainedMethod([]);
            case VendorPlugin::METHOD_AUTO:
                // Default to safe-failover method
                if (Platform::isWindows()) {
                    // Use junctions on windows environment
                    return new ChainedMethod(new JunctionMethod(), new CopyMethod());
                } else {
                    // Use symlink on non-windows environments
                    return new ChainedMethod(new SymlinkMethod(), new CopyMethod());
                }
            default:
                throw new InvalidArgumentException("Invalid method: {$key}");
        }
    }
1060220
public function get($key)
    {
        $method = 'getter' . ucfirst($key);
        if (method_exists($this, $method)) {
            return $this->$method();
        }

        return $this->getRaw($key);
    }
514477
public static function  get($key)
	{
		//check if this key exists 
		$exists = (isset($_SESSION[$key])) ? true : false;

		//return check status if false
		if ( ! $exists)  return $exists;

		//return the session data if found
		else return $_SESSION[$key];

	}