@param string $key

@return mixed

@throws Exception\PropertyException
160143
public function getAsActualType($key)
    {
        $type = $this->getType($key);
        $value = null;
        switch ($type) {
            case self::BOOLEAN: {
                $value = $this->getBoolean($key);
                break;
            }
            case self::INT: {
                $value = $this->getInt($key);
                break;
            }
            case self::FLOAT: {
                $value = $this->getFloat($key);
                break;
            }
            case self::STRING: {
                $value = $this->getString($key);
                break;
            }
            case self::DATE: {
                $value = $this->getDate($key);
                break;
            }
            case self::XML: {
                $value = $this->getXML($key);
                break;
            }
            case self::DATA: {
                $value = $this->getData($key);
                break;
            }
            case self::DATA_ARRAY: {
                $value = $this->getArray($key);
                break;
            }
            case self::OBJECT: {
                $value = $this->getArray($key);
                break;
            }
        }

        return $value;
    }
1027251
public function getAttribute($key)
    {
        $key = $this->reFormatForCompatibility($key);

        return (property_exists($this, $key)) ? $this->{$key} : null;
    }
480212
public function get($key)
    {
        if (!$this->has($key)) {
            throw new \Exception(sprintf('Identifier "%s" is not defined.', $key));
        }
        try {
            return $this->offsetGet($key);
        } catch (\Exception $exception) {
            throw $exception;
        }
    }
549587
public function offsetGet( $key )
	{
		if( !isset( $this->____pairs ) )
			$this->getPairs();
		if( !array_key_exists( $key, $this->____pairs ) )
			throw new Exception( 'Pair Key "'.$key.'" is not set in Row.' );
		if( !isset( $this->$key ) )
			return NULL;
		return $this->$key;
	}
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;
    }
611243
public function get($key)
    {
        $getResult = $this->getValue($key);
        $unserialized = @unserialize($getResult);

        if (Util::hasInternalExpireTime($unserialized)) {
            $getResult = $unserialized['v'];
        }

        return $getResult;
    }
422391
private function getUsingInternalProperty($key)
    {
        $value = false;

        if (
            array_key_exists($key, $this->internal_property_accessible) &&
            $this->internal_property_accessible[$key]
        ) {
            if ($this->hasSubDataObject($key)) {
                // return loaded sub-dataobject
                $value = $this->getSubDataObject($key);
            } elseif ($this->hasInternalValue($key)) {
                $value = $this->getInternalValue($key);

                if (
                    $value !== null &&
                    isset($this->internal_property_classes[$key])
                ) {
                    // autoload sub-dataobject
                    $class = $this->internal_property_classes[$key];

                    if (!class_exists($class)) {
                        throw new SwatClassNotFoundException(
                            sprintf(
                                "Class '%s' registered for internal property '%s' " .
                                    "does not exist.",
                                $class,
                                $key
                            ),
                            0,
                            $class
                        );
                    }

                    $this->checkDB();

                    $object = new $class();
                    $object->setDatabase($this->db);
                    $object->load($value); // autoload
                    $this->setSubDataObject($key, $object);

                    $value = $object;
                }
            }
        }

        return $value;
    }
1339735
private function getValue($key)
    {
        if (array_key_exists($key, $this->data)) {
            return $this->data[$key];
        }

        throw new AccessException('Could not get the value for the key "' . $key . '".');
    }
924205
public static function get($key)
    {
        exception_if(!array_has(self::$words, $key), LanguageKeyNotFoundException::class, $key);

        return array_get(self::$words, $key);
    }
708303
public function take($key)
    {
        self::requireSession();
        if (false === \array_key_exists($key, $_SESSION)) {
            throw new SessionException(\sprintf('key "%s" not found in session', $key));
        }
        $value = $_SESSION[$key];
        unset($_SESSION[$key]);

        return $value;
    }
172475
public function get($key)
    {
        if (! $this->enabled) {
            return;
        }
        $file = $this->getPath($key);
        if (! file_exists($file)) {
            return false;
        }

        set_error_handler(function () {
            throw new Exception('An error occurred.');
        }, E_WARNING);

        try {
            if (filemtime($file) < time()) {
                throw new Exception('Term life data has expired.');
            }
            $data = file_get_contents($file);
        } catch (Exception $ex) {
            restore_error_handler();
            $this->remove($key);

            return false;
        }
        restore_error_handler();

        return call_user_func($this->restoringFilter, $data);
    }
267077
public function get($key)
    {
        $bucket = $this->locate($key);

        if ($bucket === null) {
            $message = sprintf('Key not found: %s', VarPrinter::toString($key));
            throw new KeyException($message);
        }

        return $bucket->value();
    }
423014
public function getConfig($key)
    {
        if (!isset($this->config[$key])) {
            throw new \Exception(sprintf('No config found for key: "%s"', $key));
        }

        return $this->config[$key];
    }
1262246
public function get($key)
    {
        if (null === $this->configs) {
            $this->loadConfigs();
        }

        if (false == array_key_exists($key, $this->configs)) {
            $availableKeys = implode(', ', array_keys($this->configs));
            throw new \RuntimeException(sprintf('Config "%s" could not be found. Found: %s', $key, $availableKeys));
        }

        $config = $this->configs[$key];

        if (!$config->getValue() instanceof \stdClass || !isset($config->getValue()->Value)) {
            new \Exception(sprintf('Config "%s" should be stored as \stdClass with a Value property', $key));
        }

        return ($config->getValue() instanceof \stdClass) ? $config->getValue()->Value : $config->getValue();
    }
635934
public function get($key)
    {
        if (!$this->offsetExists($key)) {
            throw new PropelException('Unknown key ' . $key);
        }

        return $this->offsetGet($key);
    }
243573
public function getArray($key)
    {
        try {
            $result = $this->get(self::DATA_ARRAY, $key);
            if (!settype($result, 'array')) {
                return null;
            }
        } catch (\Exception $e) {
            return null;
        }
        return $result;
    }
121381
public function getMethodByAlias($key)
    {
        if (isset($this->methodList[$key]))
        {
            return $this->methodList[$key];
        }
        else
        {
            throw new Exception($key . 'method not found.');
        }
    }