iterates through all the child nodes
returns an object storage in the end

@param $key

@return mixed
358014
public function getByKey(string $key, \chilimatic\lib\Datastructure\Graph\Filter\AbstractFilter $filter = null)
    {

        $result = new \SplObjectStorage();

        if (count($this->keyList) == 0) {
            return $result;
        }

        /**
         * @var Node $node
         */
        foreach ($this->keyList[$key] as $node) {
            if (!$result->contains($node)) {
                $result->attach($node);
            }
        }

        if ($result->count() && $filter) {
            return $filter($result);
        }

        return $result;
    }
2815
public function hGetAll($key)
    {
        $this->log(__FUNCTION__, $key);
        return $this->persistence->hGetAll($key);
    }
546994
public function get($key) {
        if (!is_array($key)) {
            $key = array('key' => $key);
        }

        $key = $key['key'];
        if (isset($this->store[$key])) {
            if ($this->store[$key]['serialized']) {
                return $this->unserialize($this->store[$key]['data']);
            } else {
                return $this->store[$key]['data'];
            }
        }
        return false;
    }
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;
	}
282961
public function get($key)
    {
        $file = $this->getFilename($key);
        $data = [];
        if (file_exists($file)) {
            $data = json_decode(file_get_contents($file), true);
        }

        return Collection::make($data);
    }
453910
public function hGetAll($key) {
        return $this->send(['hgetall', $key], function ($response) {
            if ($response === null) {
                return null;
            }

            $size = \count($response);
            $result = [];

            for ($i = 0; $i < $size; $i += 2) {
                $result[$response[$i]] = $response[$i + 1];
            }

            return $result;
        });
    }
1149207
public function get($key)
    {
        $storageValue = null;
        if (true === array_key_exists($key, $this->storage)) {
            $storageValue = $this->storage[$key];
        }
        return $storageValue;
    }
1136506
public function get($key)
    {
        $response = $this->dynamo->getItem([
            'TableName' => $this->table,
            'ConsistentRead' => false,
            'Key' => [
                $this->keyAttribute => [
                    'S' => $this->prefix.$key,
                ],
            ],
        ]);

        if (! isset($response['Item'])) {
            return;
        }

        if ($this->isExpired($response['Item'])) {
            return;
        }

        if (isset($response['Item'][$this->valueAttribute])) {
            return $this->unserialize(
                $response['Item'][$this->valueAttribute]['S'] ??
                $response['Item'][$this->valueAttribute]['N'] ??
                null
            );
        }
    }
278611
protected function loadRef($key)
    {
        $attrs = $this->getAttrs();
        $reference = $attrs[$key];
        $cache = &$this->_cache;
        if (isset($this->cleanData[$key])) {
            $value = $this->cleanData[$key];
        } else {
            $value = null;
        }

        $model = $reference['model'];
        $type = $reference['type'];
        if ( isset($cache[$key]) ) {
            $obj = &$cache[$key];

            return $obj;
        } else {
            if (class_exists($model)) {
                if ($type == self::DATA_TYPE_REFERENCE) {
                    if (\MongoDBRef::isRef($value)) {
                        $object = $model::id($value['$id']);
                        $cache[$key] = $object;

                        return $object;
                    }

                    return null;
                } elseif ($type == self::DATA_TYPE_REFERENCES) {
                    $res = array();
                    if (!empty($value)) {
                        foreach ($value as $item) {
                            if(isset($item['$id'], $item['$ref'])) {
                                $record = $model::id($item['$id']);
                                if ($record) {
                                    $res[] = $record;
                                }
                            }
                        }
                    }
                    $set =  Collection::make($res);
                    $cache[$key] = $set;
                    $obj = &$cache[$key];

                    return $obj;
                }
            }
        }
    }
404778
public function tryGet($key)
    {
        if (isset($this->stash[$key])) {
            return $this->stash[$key];
        }

        if ($this->parent && $this->parent->tryGet($key) !== null) {
            return $this->parent->tryGet($key);
        }

        return null;
    }
254420
public function get($key)
    {
        if ($this->exists($key)) {
                $json = file_get_contents($this->datapath.'/data/'.$key.'.json');
                $item = $this->JsonToObj($json, $root = True);
        } else {
            $item = new jstoreRootObject($this);
        }
        $item->setKey($key);
        return $item;
    }
1280790
public function getValueStored($key)
    {
        if (isset($this->storedValues[$key])) {
            return $this->storedValues[$key];
        } else {
            return null;
        }
    }
864902
public function getNodeByKey($key): ?Node {
        $arrayIndex = $this->getBucketIndex($key);
        /*
         * the list is requested from the array based on
         * the array index hash.
         */
        /** @var SinglyLinkedList $list */
        if (!isset($this->bucket[$arrayIndex])) {
            return null;
        }
        $list = $this->bucket[$arrayIndex];
        if (!$list->containsKey($key)) {
            return null;
        }
        $node = $list->getNodeByKey($key);
        return $node;
    }
832127
protected function load($key) {
        try {
            return $this->memcached->get($key);
        } catch (\Exception $e) {
            throw new StorageException("Failed to load memcached key: $key", 1, $e);
        }
    }
213651
public static function getStore($key = null)
    {
        $ret = null;

        if ($key !== null) {
            if (isset(self::$store[$key])) {
                $ret = self::$store[$key];
            }
        } else {
            $ret = self::$store;
        }

        return $ret;
    }
546940
public function get($key) {
        if ($this->persist && array_key_exists($key, $this->store)) {
            return $this->store[$key];
        }
        return false;
    }
838578
private function generateSourceSeo($key)
    {
        if (isset($this->{$key})) {
            return $this->{$key};
        }

        $object = $this;
        foreach (explode('.', $key) as $segment) {
            if (!is_object($object) || !$tmp = $object->{$segment}) {
                return null;
            }

            $object = $object->{$segment};
        }

        return $object;
    }