Get item from map

@param mixed $key
@return mixed

@throws \OutOfBoundsException when key is not exists
540596
public function get($key)
    {
        $key = $this->getScalarKey($key);
        if (isset($this->list[$key])) {
            return $this->list[$key]->value;
        }

        throw new \OutOfBoundsException('The key ' . $key . ' is not existed.');
    }
580204
public function getBoolean($key)
	{
		$resolved = false;
		$value = $this->getByKey($key, $this->data, $resolved);
		
		if($resolved)
		{
			return $value ? true : false;
		}
		
		if(func_num_args() > 1)
		{
			return func_get_arg(1);
		}
		
		throw new \OutOfBoundsException('Configuration setting not found: "' . $key . '"');
	}
376063
public function offsetGet( $key )
    {
        $key = strtolower( $key );
        if ( !array_key_exists( $key, $this->lookup ) )
        {
            return null;
        }
        return $this->map[$this->lookup[$key]];
    }
896222
public function getObjectByKey($key)
       {
            if (isset($this->map[$key])) {
                parent::rewind();
                while(parent::valid()) {
                    if (parent::key() === $key) {
                        return parent::current();
                    }
                    parent::next();
                }
            }
       }
694985
public function get($key)
	{
		$item = new Item($key);

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

		return $item;
	}
997641
public function get($key)
	{
		if ($value = $this->memcache->get($this->prefix.$key)) {
		    return $value;
		}
	}
922382
public function get($key) {
    $out = NULL;
    // Read the json encoded value from disk if it exists.
    $path = $this->getFileName($key);
    if (file_exists($path)) {
      $out = file_get_contents($path);
      $out = json_decode($out, TRUE);
    }
    return $out;
  }
810919
public function offsetGet($key)
    {
        if (! isset($this->data[$key]) or is_array($this->data[$key])) {
            return $this->getSubset($key);
        }
        return $this->data[$key];
    }
709222
public function offsetGet($key)
    {
        if (isset($this->granules[$key])) {

            return $this->granules[$key];
        }
        throw new \OutOfBoundsException(sprintf('Granule "%s" is not defined.', $key));
    }
671232
public final function getItem($key)
   {
       try {
           if (!$this->hasItem($key)) {
               $this->pool[$key] = $this->poolGetItem($key);
           }
           return $this->pool[$key];
       } catch (InvalidArgumentException $e) {
           throw $e;
       }
   }
839030
public function getItem($key)
    {
        if (false === $this->hasItem($key)) {
            throw new ConfigException(sprintf('item "%s" not available', $key));
        }

        return $this->configData[$key];
    }
66159
public function getItem(string $key)
    {
        $this->checkCallback();
        if (isset($this->members[$key])) {
            return $this->members[$key];
        } else {
            throw new CollectionException('Unable to retrieve item from collection - key ' . $key . ' not found.');
        }
    }
997657
public function fetch($key) : Collection
    {
        $extr = [];
        foreach ($this->list as $list) {
            if (is_array($list) && key_exists($key, $list)) {
                $extr[] = $list[$key];
            }
        }

        return self::from(...$extr);
    }
1035551
public function extract($key)
    {
        $extracted = [];

        foreach ($this->items as $item) {
            foreach (func_get_args() as $key) {
                if ($item instanceof CollectionInterface) {
                    $extracted[] = $item->get($key);
                } else if (is_object($item)) {
                    $extracted[] = $item->{$key};
                } else {
                    $extracted[] = $item[$key];
                }
            }
        }

        return $extracted;
    }
1269370
public function get($name)
    {
        if (!isset($this->items[$name])
            && !array_key_exists($name, $this->items)
            && !$this->applyDefaultValue($name)
        ) {
            throw new \OutOfBoundsException(sprintf('Undefined data item index: %s.', $name));
        };

        return $this->items[$name];
    }
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;
	}
399360
public function offsetGet($key)
    {
        $result = array_get($this->items, $key);

        if (is_array($result))
            return new static($result);

        return $result;
    }