{@deprecated} Only still here for use during update.

@param array $keys

@return array
779915
public function loadOld(array $keys)
    {
        $result = array();
        $params = JComponentHelper::getParams('com_acumulus');
        foreach ($keys as $key) {
            $value = $params->get($key, null);
            if (isset($value)) {
                // Keyed arrays are saved as objects, convert back to an array.
                if (is_object($value)) {
                    // http://php.net/manual/en/language.types.array.php:
                    // If an object is converted to an array, the result is an
                    // array whose elements are the object's properties. The
                    // keys are the member variable names, with a few notable
                    // exceptions: integer properties are not accessible!
                    // So we use this strange looking but working conversion.
                    $value = json_decode(json_encode($value), true);
                }
                $result[$key] = $value;
            }
        }

        // Delete the values, this will only be used one more time: during
        // updating to 5.4.0.
        $extensionTable = new JtableExtension(JFactory::getDbo());
        $extensionTable->load(array('element' => 'com_acumulus'));
        $extensionTable->set('params', '');
        $extensionTable->store();

        return $result;
    }
837070
public function forgetMany(array $keys)
    {
        $this->connection()->del($this->prefixKeys($keys));

        return array_fill_keys($keys, true);
    }
1332584
public function getMany($keys)
    {
        if (!is_array($keys))
            $keys = func_get_args();

        $newArray = array();

        foreach($keys as $key) {
            if (isset($this->_data[$key])) {
                $newArray[$key] = $this->_data[$key];
            }
        }

        return $newArray;
    }
999026
protected function _keys($keys) {
		if (!$keys) {
			return [];
		}
		$config = $this->_config;
		$hasType = ($config['type'] === 'hasOne' || $config['type'] === 'hasMany');
		$related = Libraries::locate('models', $config[$hasType ? 'from' : 'to']);

		if (!class_exists($related)) {
			throw new ClassNotFoundException("Related model class '{$related}' not found.");
		}
		if (!$related::key()) {
			throw new ConfigException("No key defined for related model `{$related}`.");
		}
		$keys = (array) $keys;
		$related = (array) $related::key();

		if (count($keys) !== count($related)) {
			$msg = "Unmatched keys in relationship `{$config['name']}` between models ";
			$msg .= "`{$config['from']}` and `{$config['to']}`.";
			throw new ConfigException($msg);
		}
		return $hasType ? array_combine($related, $keys) : array_combine($keys, $related);
	}
314590
public function mget($keys)
	{
	    $res = [];
	    if (is_array($keys)) {
	        foreach ($keys as $k) {
	            $res[$k] = $this->get($k);
	        }
	    } else {
	        $res[$keys] = $this->get($keys);
	    }
	    
	    return $res;
	}
1008654
public final function getItems(array $keys = [])
   {
       try {
           $item = [];
           foreach ($keys as $value) {
               $item[$value] = $this->getItem($value);
           }
       } catch (InvalidArgumentException $e) {
           throw $e;
       }
       return $item;
       
   }
154419
public function select(array $keys)
    {
        $list = [];
        foreach ($keys as $key) {
            if ($this->containsKey($key)) {
                $list[$key] = $this->get($key);
            }
        }

        return $this->createFrom($list);
    }
36439
public function pick(array $keys) {
        $data = [];

        foreach ($keys as $key) {
            array_set($data, $key, $this->get($key));
        }

        return $data;
    }
429901
protected function doFetchMultiple(array $keys)
    {
        $returnValues = [];

        foreach ($keys as $key) {
            $item = $this->doFetch($key);
            if ($item === false && ! $this->doContains($key)) {
                continue;
            }

            $returnValues[$key] = $item;
        }

        return $returnValues;
    }
573857
public static function fromKeys($keys){
        $hash = new Dictionary();
        foreach($keys as $key){
            $hash[$key] = NULL;
        }
        return $hash;
    }
1098167
public function getAttributeArray( $keys ) {

		$data = [];

		foreach( $keys as $key ) {

			$data[ $key ] = $this->$key;
		}

		return $data;
	}
1294663
public static function filterKeys(array $array, array $keys): array
	{
		$keysKeys = array_flip($keys);
		$presentKeysKeys = array_intersect_key($keysKeys, $array);
		$presentKeys = array_flip($presentKeysKeys);

		$filtered = [];
		foreach ($presentKeys as $key) {
			$filtered[$key] = $array[$key];
		}

		return $filtered;
	}
45386
public function forgetMany(array $keys)
    {
        if (! method_exists($this->memcached, 'deleteMulti')) {
            return array_combine($keys, array_map([$this, 'forget'], $keys));
        }

        $result = $this->memcached->deleteMulti($this->prefixKeys($keys));

        return array_fill_keys($keys, $result);
    }
310396
private function parseKeys($keys)
    {
        if (is_string($keys)) {
            if (strpos($keys, '[') !== false) {
                $keys = str_replace(']', '', $keys);
                $keys = explode('[', trim($keys, '['));
            } else {
                $keys = (array) $keys;
            }
        }

        return $keys;
    }
296917
public function only($keys)
    {
        $keys = is_array($keys) ? $keys : func_get_args();

        $results = [];
        foreach ($keys as $key) {
            $results = array_merge_recursive($results, $this->buildArray(explode('.', $key), $this->get($key)));
        }

        return $results;
    }
31079
public function just(array $keys = []): array
    {
        if (!is_array($keys) || !count($keys)) {
            return [];
        }
        $just = [];
        foreach ($this->public as $key => $value) {
            if (in_array($key, $keys)) {
                $just[$key] = $value;
            }
        }
        return $just;
    }
440923
public function normalizeKeys($keys)
    {
        if ($keys === true) {
            $keys = $this->keys();
        }

        if (empty($keys)) {
            return [];
        }

        return $this->_normalizeAssociations($keys);
    }