Returns an API-compliant representation of a KeyRange.

@return array
@access private
339009
public function keyRangeObject()
    {
        if (!$this->start || !$this->end) {
            throw new \BadMethodCallException('Key Range must supply a start and an end');
        }

        return [
            $this->startType => $this->start,
            $this->endType => $this->end
        ];
    }
673137
public function keys()
    {
        return array_map(
            function ($key) {
                $chunks = explode('_', $key);

                return array_pop($chunks);
            },
            array_keys($this->pagers)
        );
    }
384087
private function generateKeys()
    {
        $content = [];
        for ($i = 0; $i < count($this->keys); $i++) {
            $holder = [];
            $value = !$this->option($this->keys[$i]) || $this->option($this->keys[$i]) === 'generate' ? str_random(64) : $this->option($this->keys[$i]);
            $holder['regex'] = str_replace_first($this->findRegExPlaceholder, $this->keys[$i], $this->findRegEx);
            $holder['value'] = $this->keys[$i] . '="' . $value . '"';
            array_push($content, $holder);
        }

        return $content;
    }
1038609
public function get_key_list() {
        $keys = array();
        foreach ($this->collection as $node) {
            $keys[] = $node->key;
        }
        return $keys;
    }
64437
public function key()
    {
        if ($this->assocArray) {
            $keys = array_keys($this->val);
            return $keys[$this->position];
        }

        return $this->position;
    }
1214913
final public function getPrimaryKeyValues() : array
    {
        $keys = static::getPrimaryKeys();
        $values = array_intersect_key($this->data, array_flip($keys));

        return $values;
    }
1352322
public function getAllKeyValues()
    {
        $query = $this->_table->query();

        $query->formatResults(function (ResultSet $results) {
            return $results->map(function ($row) {
                if ($row['serialized'] === true) {
                    $row['value'] = unserialize($row['value']);
                }
                return $row;
            });
        });

        $settings = [];

        foreach ($query->all() as $row) {
            $key = $row['scope'] . '__' . $row[$this->config('fields.key')];
            $value = $row[$this->config('fields.value')];
            $settings[$key] = $value;
        }

        return Hash::expand($settings, '__');
    }
930658
public function getKeys()
    {
        if ($this->_keys === null) {
            $this->_keys = $this->getResolvedPathInfo($this->request)->resolvedValues;
        }
        
        return $this->_keys;
    }
379565
public function getPrimaryKey()
    {
        $keys = array();
        $columns = $this->getColumns(true);

        foreach ($columns as $name => $description)
        {
            if ($description->primary) {
                $keys[$name] = $description;
            }
        }

        return $keys;
    }
787137
protected function get_key_from_position() {
        $keylist = array_keys($this->contextlists);
        if (isset($keylist[$this->iteratorposition])) {
            return $keylist[$this->iteratorposition];
        }

        return null;
    }
616527
public function getQualifiedKeyName()
    {
        $keyName = $this->getKeyName();

        if (is_array($keyName)) { //Check for multi-columns relationship
            $keys = [];

            foreach ($keyName as $key) {
                $keys[] = $this->getTable().$key;
            }

            return $keys;
        }

        return $this->getTable().'.'.$keyName;
    }
47175
public function getAuthKeyRules()
    {
        if (!is_string($this->authKeyAttribute) || empty($this->authKeyAttribute)) {
            return [];
        }
        if (empty($this->authKeyRules)) {
            $this->authKeyRules = [
                [[$this->authKeyAttribute], 'required'],
                [[$this->authKeyAttribute], 'string', 'max' => 40],
            ];
        }
        return $this->authKeyRules;
    }
861795
public function keys()
    {
        if (!$this->__connect()) {
            return array();
        }

        $meta = $this->getMeta();
        if (!is_array($meta) || !array_key_exists(Memento\Hash::FIELD_KEYS, $meta)) {
            $this->__disconnect();

            return array();
        }

        $keys = $this->memcache->get($meta[Memento\Hash::FIELD_KEYS]);
        $this->__disconnect();

        if (!is_array($keys)) {
            return array();
        }

        return array_keys($keys);
    }
808145
public function getNames()
    {
        if($this->isKeycacheInvalid())
        {
            $this->regenerateKeyCache();
        }
        if(is_array($this->__keycacheindex))
        {
            return $this->__keycacheindex;
        }
        return array();
    }
1020966
public function getRange($key, $length) {
        $badKeys = [];

        for ($i = 0; $i < $key; $i++) {
            array_push($badKeys, $i);
        }

        for ($i = $key + $length; $i < count($this->_datas); $i++) {
            array_push($badKeys, $i);
        }

        return array_diff_key($this->_datas, array_flip($badKeys));
    }
1096465
public function key()
    {
        switch ($this->flags & 0xF0) {
            default:
            case self::CURRENT_ARRAY:
                return [$this->lhs->key(), $this->rhs->key()];
            case self::CURRENT_LHS:
                return $this->lhs->key();
            case self::CURRENT_RHS:
                return $this->rhs->key();
            case self::CURRENT_0:
                return null;
        }
    }
406084
public function getAllKey()
    {
        $keys = array();
        // First, let's merge all the arrays in order to get all the keys:
        foreach ($this->getAllTranslationByLanguage() as $translations) {
            $keys = array_merge($keys, $translations);
        }

        return array_keys($keys);
    }