When matching by key, we accept user group Id and it's remote Id only
@param int|string $key
@return array
347991
protected function getConditionsFromKey($key)
    {
        if (is_int($key) || ctype_digit($key)) {
            return array(self::MATCH_USERGROUP_ID => $key);
        }
        return array(self::MATCH_CONTENT_REMOTE_ID => $key);
    }
1275485
public final function &getSharedArray($key)
    {
        if (!isset($this->sharedData[$key])){
            $this->sharedData[$key] = [];
        }

        return $this->sharedData[$key];
    }
189188
public function getGroupData($key, $id = 0)
    {
        // Get Group id
        if (!$id) {
            $id = $this->getUserData('group_id');
        } else {
            $id = abs((int)$id);
        }

        // Check or init cache
        if (!isset(self::$cached_group_data[$id])) {
            $group = new AdminUserGroup($id);
            self::$cached_group_data[$id] = $group->getAsArray();
        }

        return isset(self::$cached_group_data[$id][$key]) ? self::$cached_group_data[$id][$key] : NULL;
    }
1199367
private function lookupKey($key)
    {
        foreach ($this->pairs as $pair) {
            if ($this->keysAreEqual($pair->key, $key)) {
                return $pair;
            }
        }
    }
1175675
private static function createPassKey($key)
    {
        /**
         * ------------------------------------
         * Safe Sanitized hash
         * ------------------------------------
         */
        (is_null($key) || $key === false) && $key = '';
        // safe is use array or object as hash
        $serialize_key      = @serialize($key);
        if (!$serialize_key) {
            throw new \ErrorException(
                sprintf(
                    'Could not serialize input key of %s',
                    gettype($serialize_key)
                )
            );
        }

        /**
         * ------------------------------------
         * Set Key
         * ------------------------------------
         */

        $key       = pack('H*', self::hashStringContainer($serialize_key));
        return [
            $serialize_key,
            self::safeBase64Encode(str_pad($key, 24, "\0", STR_PAD_RIGHT))
        ];
    }
81629
public function retrieve($key)
    {
//        if (!is_array($key)) {
//            return;
//        }
        list($name, $userId) = explode('/user-', $key);

        if (!isset($this->userMeta[$userId])) {
            $data = $this->getModel()->where('user_id', '=', $userId)->get();

            $this->userMeta[$userId] = $this->processRetrievedData($userId, $data);
        }

        return Arr::get($this->userMeta, "{$userId}.{$name}");
    }
164039
public function getArray($key)
	{
		$this->validateKey($key);
		return $this->has($key) ? $this->params[$key] : [];
	}
1014094
public function get(string $group, string $key)
    {
        return $this->values[$group][$key] ?? null;
    }
1077124
public function get(string $key)
    {
        $slug = $this->splitKey($key);

        if (is_string($slug)) {
            if (isset($this[$slug])) {
                return $this[$slug];
            }
            return null;
        }

        $array = $this->toArray();

        foreach ($slug as $search) {
            if (isset($array[$search])) {
                $array = $array[$search];
            } else {
                return;
            }
        }

        return $array;
    }
1124397
function &get($key) {
		if ($key=='_id')
			return $this->id;
		if (array_key_exists($key,$this->item))
			return $this->item[$key];
		user_error(sprintf(self::E_Field,$key),E_USER_ERROR);
		return FALSE;
	}
1338178
protected function getConfigItem(string $key)
    {
        if ($this->config === null) {
            $this->config = $this->container->config->get('exceptions', []);
        }

        return array_get($this->config, $key);
    }
1308804
public function get($key) {
		$row = $this->db->dal()->from($this->getTable())->where('key', $key)->first();
		if(isset($row['value'])) {
			$res = unserialize($row['value']);
			if(isset($res['_dataType']) && isset($res['input']))
				return $this->types[$res['_dataType']][1]($res['input']);
			else
				return $res;
		}
	}
1240837
static function groups($key = null)
    {
        if (!isset(self::$trace)) self::$trace = new Trace('TRACE');
        if (isset($key)){
            return self::$trace->__get($key);
        }else{
            return self::$trace;
        }
    }
32154
public function getId($key = null)
    {
        return (isset($this->index[$key]) && !is_null($key)) ?
            $this->index[$key] :
            $this->index[$this->getKeyName()];
    }
1053099
public function getModulePermissions($key)
    {
        $this->prepareData();

        if ( ! array_key_exists($key, $this->modulePermissions)) {
            return [];
        }

        return $this->modulePermissions[$key];
    }
1030559
public function getKey($key) {
		$out = NULL;
		if ($this->hasKey($key)) {
			$out = $this->key[$key];
			unset($this->key[$key]);
		}
		return $out;
	}
233038
public function get($key)
    {
        $data = [];
        $data = $this->memcached()->get($key);

        return ($this->memcached()->getResultCode() == 0) ? $data : null;
    }