Gets a value given the path in the registry.

@param scalar[, scalar..] $modified The registry path; yea i know this is wierd

@return mixed
513927
public function get($modified = true)
    {
        //get args
        $args = func_get_args();
        
        if (count($args) == 0) {
            return null;
        }
        
        $last = array_pop($args);
        $pointer = &$this->data;
        foreach ($args as $step) {
            if (!isset($pointer[$step])) {
                return null;
            }

            $pointer = &$pointer[$step];
        }
        
        if (!isset($pointer[$last])) {
            return null;
        }
        
        return $pointer[$last];
    }
462540
public function getData($key, $registry = null)
	{
		if ($registry == null) {
			$registry = $this->default;
		}
		if (is_string($key . $registry) && $this->registryExists($registry)) {
			if (array_key_exists($key, $this->data[self::REGISTRY][$registry])) {
				return $this->data[self::REGISTRY][$registry][$key];
			}
		}
		return null;
	}
1180896
public function offsetGet($offset)
    {
        if ($this->offsetExists($offset)) {
            return $this->items[$offset];
        }
        if ($this instanceof MandatoryKeyInterface) {
            throw new RuntimeException('Item does not exist at key: ' . $offset);
        }
        return null;
    }
1226965
public function getPath($class)
    {
        if(!$this->__registry->has($class))
        {
            if(!$locator = $this->__registry->getLocator($class))
            {
                $locators = $this->getLocators();

                foreach($locators as $locator)
                {
                    if(false !== $path = $locator->locate($class))
                    {
                        $this->__registry->setLocator($class, $locator->getName());
                        break;
                    };
                }
            }
            else $path = $this->getLocator($locator)->locate($class);

            $this->__registry->set($class, $path);

        }
        else $path = $this->__registry->get($class);

        return $path;
    }
695309
public function extract($path)
	{
		$data = $this->get($path);

		if ($data === null)
		{
			return null;
		}

		return new Registry($data);
	}
227014
public function get ($path) {
		list ($first, $rest) = self::getFirstAndRestPathElements($path);

		if (array_key_exists($first, $this -> data)) {
			$value = $this -> data[$first];
			if (is_null($rest)) {
				return $value;
			} else if ($value instanceof TreeInterface) {
				return $value -> get($rest);
			} else {
				throw new InvalidKeyException("Value at key `" . $first . "` is a scalar; cannot step further down the requested path `" . $rest . "`");
			}
		} else {
			throw new NonExistentKeyException("Key `" . $first . "` does not exist.");
		}
	}
994280
protected function loadFromRegistry(string $key)
    {
        return array_key_exists($key, $this->registry) ? $this->registry[$key] : null;
    }
1317438
public function &get($path = '')
  {
    $this->_tmp = &$this->_current;
    $this->_shiftTmp($path);
    return $this->_tmp;
  }
1074409
public function offsetGet($offset) {
    return isset($this->__items[$offset]) ? $this->__items[$offset] : null;
  }
1277440
public function offsetGet($offset)
    {
        $value = isset($this->arguments[$offset]) ? $this->arguments[$offset]->getRaw() : null;
        return $value;
    }
244796
public function offsetGet($offset)
    {
        //argument 1 must be scalar, null or bool
        Argument::i()->test(1, 'scalar', 'null', 'bool');
        
        $pathArray = $this->getArray();

        if ($offset == 'first') {
            $offset = 0;
        }

        if ($offset == 'last') {
            $offset = count($pathArray) - 1;
        }

        if (is_numeric($offset)) {
            return isset($pathArray[$offset]) ? $pathArray[$offset] : null;
        }

        return null;
    }
1368908
protected function getRequest($url, $parameters = [], $modified = null)
    {
        if (!empty($parameters)) {
            $this->parameters->addGet($parameters);
        }

        return $this->request($url, $modified);
    }
260651
public function getValue(
        $path = null,
        $scope = ScopeConfigInterface::SCOPE_TYPE_DEFAULT,
        $scopeCode = null
    ) {
        return $this->scopePool->getScope($scope, $scopeCode)->getValue($path);
    }
445544
public function get($path, $default = null)
	{
		// Return default value if path is empty
		if (empty($path))
		{
			return $default;
		}

		if (!strpos($path, $this->separator))
		{
			return (isset($this->data->$path) && $this->data->$path !== null && $this->data->$path !== '') ? $this->data->$path : $default;
		}

		// Explode the registry path into an array
		$nodes = explode($this->separator, trim($path));

		// Initialize the current node to be the registry root.
		$node  = $this->data;
		$found = false;

		// Traverse the registry to find the correct node for the result.
		foreach ($nodes as $n)
		{
			if (\is_array($node) && isset($node[$n]))
			{
				$node  = $node[$n];
				$found = true;

				continue;
			}

			if (!isset($node->$n))
			{
				return $default;
			}

			$node  = $node->$n;
			$found = true;
		}

		if (!$found || $node === null || $node === '')
		{
			return $default;
		}

		return $node;
	}
1114305
public function offsetGet($offset)
	{
		list($index_name, $key) = $this->normalizeAccessKey($offset);

		return $this->get($key, null, $index_name);
	}
767967
public function get($path)
    {
        $path = self::validatePath($path);
        $fullPath = $this->getMediaPath($path);
        return $this->getStorageDisk()->get($fullPath);
    }
1164477
public function offsetGet($key) {

    $resolved_key = $this->arguments_spec->normalizeOptionName($key);
    if ($resolved_key === null) {
      if (isset($this->merged_arg_values[$key])) {
        return parent::offsetGet($key);
      }
    }

    if (isset($this->merged_arg_values[$resolved_key])) {
      return parent::offsetGet($resolved_key);
    }

    return null;
  }