{@inheritDoc}
@see \common_persistence_AdvKvDriver::keys()
488351
public function keys($pattern)
    {
        $this->seeks++;
        if ($this->detailedLogging) {
            \common_Logger::w('Call for '.$key.' ('.$call.')');
        }
        return $this->persistence->keys($pattern);
    }
1076215
protected function getKeys()
    {
        $identifier = $this->getIdentifier();

        $query = new Query();
        $selectNode = new Node\SelectNode([$identifier]);
        $query->setSelect($selectNode);
        $queryResult = $this->query($query);
        $keysArray = [];

        foreach ($queryResult as $row) {
            $keysArray[] = $row[$identifier];
        }

        return $keysArray;
    }
476197
public function keep($keys)
    {
        foreach ((array)$keys as $key) {
            $this->flash($key, $this->get($key));
        }
    }
671243
public function keys()
    {
        $map = new Map;
        foreach (array_keys($this->array) as $hash) {
            $map[] = $this->hash_to_key($hash);
        }
        return $map;
    }
627792
public function many(array $keys)
    {
        $prefixedKeys = array_map(function ($key) {
            return $this->prefix.$key;
        }, $keys);

        if ($this->onVersionThree) {
            $values = $this->memcached->getMulti($prefixedKeys, Memcached::GET_PRESERVE_ORDER);
        } else {
            $null = null;

            $values = $this->memcached->getMulti($prefixedKeys, $null, Memcached::GET_PRESERVE_ORDER);
        }

        if ($this->memcached->getResultCode() != 0) {
            return array_fill_keys($keys, null);
        }

        return array_combine($keys, $values);
    }
252324
public function all( $keys = null ) {
		$input = array_replace_recursive( $this->input(), $this->all_files() );

		if ( ! $keys ) {
			return $input;
		}

		$results = [];

		foreach ( is_array( $keys ) ? $keys : func_get_args() as $key ) {
			Arr::set( $results, $key, Arr::get( $input, $key ) );
		}

		return $results;
	}
782086
public function many(array $keys)
    {
        $results = [];

        $values = $this->connection()->mget(array_map(function ($key) {
            return $this->prefix.$key;
        }, $keys));

        foreach ($values as $index => $value) {
            $results[$keys[$index]] = ! is_null($value) ? $this->unserialize($value) : null;
        }

        return $results;
    }
355660
public function addKeys( $keys )
	{
		if( !is_array( $keys ) )
			throw new InvalidArgumentException( 'An Array should be given.' );
		foreach( $keys as $key )
			$this->addKey( $key );
	}
997062
public function filterByPrimaryKeys($keys)
    {
        if (empty($keys)) {
            return $this->add(null, '1<>1', Criteria::CUSTOM);
        }
        foreach ($keys as $key) {
            $cton0 = $this->getNewCriterion(PersonFunctionVersionTableMap::ID, $key[0], Criteria::EQUAL);
            $cton1 = $this->getNewCriterion(PersonFunctionVersionTableMap::VERSION, $key[1], Criteria::EQUAL);
            $cton0->addAnd($cton1);
            $this->addOr($cton0);
        }

        return $this;
    }
1172773
private function keysList(array $keys)
    {
        $out = [];
        foreach ($keys as $key) {
            $local = [];

            if (isset($key['partitionId'])) {
                $p = $this->arrayFilterRemoveNull([
                    'project_id' => isset($key['partitionId']['projectId'])
                        ? $key['partitionId']['projectId']
                        : null,
                    'namespace_id' => isset($key['partitionId']['namespaceId'])
                        ? $key['partitionId']['namespaceId']
                        : null
                ]);

                $local['partition_id'] = new PartitionId($p);
            }

            $local['path'] = [];
            if (isset($key['path'])) {
                foreach ($key['path'] as $element) {
                    $local['path'][] = new PathElement($element);
                }
            }

            $out[] = new Key($local);
        }

        return $out;
    }
859332
public function keys()
    {
        $this->bootOnce();

        $uniqueKeys = [];

        $unsettedKeys = $this->getUnsettedKeys();

        foreach (array_keys($this->_attributes) as $key) {
            $uniqueKeys[$key] = true;
        }

        foreach ($this->select(null, $this->quotedIdKey) as $row) {

            $key = $row[$this->idKey];

            if (in_array($key, $unsettedKeys)) {
                continue;
            }

            $uniqueKeys[$key] = true;;
        }

        return new StringList(array_keys($uniqueKeys));
    }
97243
public function filterByPrimaryKeys($keys)
    {
        if (empty($keys)) {
            return $this->add(null, '1<>1', Criteria::CUSTOM);
        }
        foreach ($keys as $key) {
            $cton0 = $this->getNewCriterion(UserRoleTableMap::COL_USER_ID, $key[0], Criteria::EQUAL);
            $cton1 = $this->getNewCriterion(UserRoleTableMap::COL_ROLE_ID, $key[1], Criteria::EQUAL);
            $cton0->addAnd($cton1);
            $this->addOr($cton0);
        }

        return $this;
    }
276083
public function keys($pattern)
    {
        $keys = $this->getDriver()->keys($pattern);

        if ($this->hasMaxSize()) {
            foreach ($keys as $index => $key) {
                if ($this->isMappedKey($key)) {
                    unset($keys[$index]);
                }
            }
        }
        return $keys;
    }
664550
protected function getWildcardKeys($data, array $keys) {
        $values = [];

        if ( ! is_array($data) && ! $data instanceof Traversable) {
            if ($data instanceof IArrayable) {
                $data = $data->toArray();
            }

            if ( ! is_array($data)) {
                $data = [];
            }
        }

        foreach ($data as $itemKey => $itemValue) {
            $values[$itemKey] = $itemKey;
        }

        return $values;
    }
745007
protected function getAnyKey(array $keys)
    {
        foreach($keys as $key)
        {
            $value = $this->getValue($key);

            if(!is_null($value))
            {
                return $value;
            }
        }
    }
430636
public function getKeys() {
        $keys = [];
        foreach($this->arrays as $array) {
            $keys = array_merge($keys, $array instanceof \ArrayAccess ? $array->getKeys():array_keys($array));
        }
        return array_unique($keys);
    }
133453
public function keys()
    {
        $keyPath = $this->getKeyPath();

        // find all the cached filenames among partitioned dirs within this group key
        // (e.g. '[GROUP PARTITION]/[GROUP]/[PARTITION]/[KEY]/cache')
        $iterator  = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($keyPath));

        $regIterator = new \RegexIterator($iterator, '/\/[\d]+\/[\w\d]+\/' . self::FILENAME_CACHE .'$/i');
        $keys = array();

        foreach ($regIterator as $path) {
            // extract key from file path
            preg_match('/\/(?<key>[\w\d]+)\/' . self::FILENAME_CACHE . '/', $path->__toString(), $match);
            if (!array_key_exists('key', $match) || empty($match['key'])) {
                continue;
            }
            // decode the key
            $entry = base64_decode($match['key']);
            $keys[] = $entry;
        }
        asort($keys);

        return $keys;
    }