@param string $key

@return object

@throws Exception\PropertyException
358769
public function getObject($key)
    {
        try {
            $result = $this->get(self::OBJECT, $key);
            if (!settype($result, 'object')) {
                return null;
            }
        } catch (\Exception $e) {
            return null;
        }
        return $result;
    }
561465
private function getByPropertyName($key)
    {
        if (($key = $this->getArrayKey($key)) !== static::NOT_FOUND) {
            if (is_array($this->items[$key])) {
                return $this->__wrap($this->items[$key]);
            }

            return $this->items[$key];
        }

        return static::NOT_FOUND;
    }
638773
public function get($key)
	{
		if(($key === NULL) || $key === '')
		{
			throw new JSONException('Null key.');
		}
		
		$object = $this->opt($key);
		
		if($object == NULL)
		{
			throw new JSONException('JSONArray[' . JSONObject::quote($key) . '] not found.');
		}
		
		return $object;
	}
501125
public function get($key)
    {
        if ($this->isValidKey($key)) {
            if ($this->hasIndex($key)) {
                return $this->_map[$key];
            }
        } else {
            throw new MapException('try to access with invalid map key.', E_NOTICE);
        }
        return null;
    }
457793
public function get($key)
    {
        if(!$this->has($key)) {
            throw new MissingKeyException(sprintf('No value for requested key: %s', $key));
        }

        return $this->session->get($this->path.$key);
    }
1119928
public function get(string $key)
    {
        if ($this->has($key)) {
            return deep_clone($this->parameters[$key]);
        }

        throw ParameterNotFoundExceptionFactory::create($key);
    }
1050953
public function get($key, $default = null) {
        if (!is_string($key)) throw new IllegalTypeException('Illegal type of parameter $key: '.gettype($key));
        // TODO: a numerically indexed property array will have integer keys

        $notFound = false;
        $value = $this->getProperty($key, $notFound);

        if ($notFound) {
            if (func_num_args() == 1) throw new RuntimeException('No configuration found for key "'.$key.'"');
            return $default;
        }
        return $value;
    }
694985
public function get($key)
	{
		$item = new Item($key);

		if ($this->exists($key))
		{
			$item->setValue(xcache_get($key));
		}

		return $item;
	}
611243
public function get($key)
    {
        $getResult = $this->getValue($key);
        $unserialized = @unserialize($getResult);

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

        return $getResult;
    }
1316169
public static function get($key)
    {
        $key = strtoupper($key);

        $list = static::loadConstants();

        if(array_key_exists($key,$list))
            return static::loadConstants()[$key];

        if(static::exist($key))
            return $key;

        // Throw exception.
        static::invalidType();
    }
1317806
public static function get($key)
		{
			self::_cleanPrevious();

			if(!isset($_SESSION[self::$_sessionKey.$key]) && self::$_defaultReturn=="ST__EXCEPTION")
			{
				throw new \Exception("Message with key: ".$key." doesn't exist",404);
			}

			$message = isset($_SESSION[self::$_sessionKey.$key]) ? $_SESSION[self::$_sessionKey.$key] : null;
			if(isset($message[2]['readOnce']) && $message[2]['readOnce'])
			{
				self::remove($key);
			}

			return $message ? $message[1] : self::$_defaultReturn;
		}
1094159
public function get($key)
	{
		// If the cached data has expired remove it and return.
		if ($this->exists($key) && $this->isExpired($key))
		{
			try
			{
				$this->remove($key);
			}
			catch (\RuntimeException $e)
			{
				throw new \RuntimeException(sprintf('Unable to clean expired cache entry for %s.', $key), null, $e);
			}

			return new Item($key);
		}

		if (!$this->exists($key))
		{
			return new Item($key);
		}

		$resource = @fopen($this->fetchStreamUri($key), 'rb');

		if (!$resource)
		{
			throw new \RuntimeException(sprintf('Unable to fetch cache entry for %s.  Connot open the resource.', $key));
		}

		// If locking is enabled get a shared lock for reading on the resource.
		if ($this->options['file.locking'] && !flock($resource, LOCK_SH))
		{
			throw new \RuntimeException(sprintf('Unable to fetch cache entry for %s.  Connot obtain a lock.', $key));
		}

		$data = stream_get_contents($resource);

		// If locking is enabled release the lock on the resource.
		if ($this->options['file.locking'] && !flock($resource, LOCK_UN))
		{
			throw new \RuntimeException(sprintf('Unable to fetch cache entry for %s.  Connot release the lock.', $key));
		}

		fclose($resource);

		$item = new Item($key);
		$item->setValue(unserialize($data));

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

        return (property_exists($this, $key)) ? $this->{$key} : null;
    }
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;
    }
402740
public function &get($key) {
        if ($this->has($key)) {
            $object = $this->_registered[$key];

            if ($object instanceof Closure) {
                $object = $this->set(call_user_func($object), $key);
            }

            return $object;
        }

        throw new MissingObjectException(sprintf('Object %s does not exist in the container', $key));
    }
165586
public function & get( $key )
	{
		if( !isset( $GLOBALS[$this->poolKey][$key] ) )
			throw new InvalidArgumentException( 'No Object registered with Key "'.$key.'"' );
		return $GLOBALS[$this->poolKey][$key];
	}
610987
public function getIndexingProperty($key)
    {
        $this->loadIndexingProperties();

        if (!array_key_exists($key, $this->indexingProperties)) {
            throw new \InvalidArgumentException(
                'No indexing property "' . $key . '".',
                1323174143
            );
        }

        return $this->indexingProperties[$key];
    }