@param string $dotKey

@return mixed
17053
public function searchByKey(string $dotKey){

		foreach($this->iterator as $v){

			if($this->getPath() === $dotKey){
				return $v;
			}

		}

		return null;
	}
503513
public function get($key)
    {
        if (isset($this->cache[$key])) {
            list($expires, $value) = $this->cache[$key];
            if (!$expires || ($expires >= microtime(true))) {
                return $value;
            }
            unset($this->cache[$key]);
        }
        return false;
    }
420816
public function get($key)
    {
        if (\array_key_exists($key, $this->array)) {
            $res = $this->array[$key];
            if ($res instanceof Basic) {
                return $res->getValue();
            } elseif ($res instanceof self) {
                return $res->toArray();
            } else {
                return $res;
            }
        } else {
            return;
        }
    }
258843
protected function &_getKey($key)
    {
        $default = null;
        $parts = is_string($key) ? explode('.', $key) : $key;

        switch (count($parts)) {
            case 1:
                if (isset($this->_info[$parts[0]])) {
                    return $this->_info[$parts[0]];
                }

                return $default;
            case 2:
                if (isset($this->_info[$parts[0]][$parts[1]])) {
                    return $this->_info[$parts[0]][$parts[1]];
                }

                return $default;
            case 3:
                if (isset($this->_info[$parts[0]][$parts[1]][$parts[2]])) {
                    return $this->_info[$parts[0]][$parts[1]][$parts[2]];
                }

                return $default;
            case 4:
                if (isset($this->_info[$parts[0]][$parts[1]][$parts[2]][$parts[3]])) {
                    return $this->_info[$parts[0]][$parts[1]][$parts[2]][$parts[3]];
                }

                return $default;
            default:
                $data = $this->_info;
                foreach ($parts as $key) {
                    if (is_array($data) && isset($data[$key])) {
                        $data = $data[$key];
                    } else {
                        return $default;
                    }
                }
        }

        return $data;
    }
576336
public function get($key)
	{
		$value = xcache_get($this->id($key));

		if (isset($value))
		{
			return $value;
		}
	}
79537
public function set(string $dotKey, $value){

		if(empty($dotKey)){
			$this->array = $value;

			return $this;
		}

		$array = &$this->array;
		$keys = \explode('.', $dotKey);

		while(\count($keys) > 1){
			$dotKey = \array_shift($keys);

			// If the key doesn't exist at this depth, we will just create an empty array
			// to hold the next value, allowing us to create the arrays to hold final
			// values at the correct depth. Then we'll keep digging into the array.
			if(!isset($array[$dotKey]) || !\is_array($array[$dotKey])){
				$array[$dotKey] = [];
			}

			$array = &$array[$dotKey];
		}

		$array[\array_shift($keys)] = $value;

		return $this;
	}
902652
public function get($key)
    {
        try {
            return $this->redis->get($key);
        } catch (\RedisException $e) {
            die("Error!: " . $e->getMessage() . "<br/>");
        }
    }
584859
public function get(string $key, $default = null)
    {
        if (array_key_exists($key, $this->input)) {
            return $this->input[$key];
        } elseif (array_key_exists($key, $this->cache)) {
            return $this->cache[$key];
        }

        // No dot, then not nested keys. We already tried that key and were not lucky.
        if (false === strpos($key, '.')) {
            return $this->default($default);
        }

        try {
            $return = $this->find($this->input, $key);
        } catch (\Exception $e) {
            $return = $this->default($default);
        }
        return $return;
    }
1030559
public function getKey($key) {
		$out = NULL;
		if ($this->hasKey($key)) {
			$out = $this->key[$key];
			unset($this->key[$key]);
		}
		return $out;
	}
321980
public function &offsetGet($key)
    {
        if(!$this->has($key))
            return null;

        return DotArray::getReference($this->storage, $key);
    }
830721
public function get(string $key)
    {
        $keyMD5 = md5($key);
        $value = $this->dataRepository->getValue($this->keyPrefix . substr($keyMD5, 0, 3) . '/' . substr($keyMD5, 3) . '.2');
        if ($value !== null) {
            try {
                $value = unserialize(gzuncompress($value));
                if ($value[0] > 0) {
                    if ($value[0] > time()) {
                        return $value[1];
                    }
                    return null;
                }
                return $value[1];
            } catch (\Exception $e) {
                
            }
        }
        return null;
    }
519400
public function getMeta($key)
    {
    	$postmeta = $this->postmeta;
    	$postmeta = $postmeta->keyBy('meta_key');
		if(array_has($postmeta, $key . '.meta_value')){
			$returnValue = $postmeta[$key]['meta_value'];
			return $returnValue;
		}
    }
733707
public function get( $key )
	{
		$prefixed = $this->prefix . $key;

		$cache = $this->table()->where( 'key', '=', $prefixed )->first();

		// If we have a cache record we will check the expiration time against current
		// time on the system and see if the record has expired. If it has, we will
		// remove the records from the database table so it isn't returned again.
		if ( !is_null( $cache ) )
		{
			if ( is_array( $cache ) )
				$cache = (object) $cache;

			if ( time() >= $cache->expiration )
			{
				$this->forget( $key );

				return null;
			}

			return $this->encrypter->decrypt( $cache->value );
		}

		return null;
	}
285276
public function get($key)
    {
        if ($this->has($key)) {
            $flashMessages = $this->storage->get(self::FLASH_KEY);
            $message = $flashMessages[$key];

            $this->remove($key);

            if ($this->translator instanceof TranslatorInterface) {
                $message = $this->translator->translate($message);
            }

            return $message;
        } else {
            throw new RuntimeException(sprintf(
                'Attempted to read non-existing key %s', $key
            ));
        }
    }
242551
public function getGetItem($key)
    {
        return isset($this->get[$key]) ? $this->get[$key] : null;
    }
105808
public function get($key, $default = null, $dot_syntax = true)
    {
        if ($dot_syntax === true) {
            $paths = explode('.', $key);
            $node =& $this->_data;
            
            foreach ($paths as $path) {
                if (!is_array($node) || !isset($node[$path])) {
                    // error occurred
                    return $default;
                }
                $node =& $node[$path];
            }
            
            return $node;
            
        } else {
            
            return isset($this->_data[$key]) ? $this->_data[$key] : $default;
            
        }
    }
852603
public function get($cacheKey)
    {
        // TODO: Refactor for strict types!
        $path = $this->resolvePath($cacheKey, false);
        if (file_exists($path)) {
            return file_get_contents($path);
        }

        return null;
    }