Get Coordinate Map by key or all from the actived sheet

@param string|int $key Key set by addRow()
@return string|array Coordinate string | Key-Coordinate array
12555
public static function getCoordinateMap($key=NULL)
    {
        if ($key) {
            return isset(self::$_keyCoordinateMap[$key]) ? self::$_keyCoordinateMap[$key] : NULL;
        } else {
            return self::$_keyCoordinateMap;
        }
    }
121497
protected function getNested(string $key)
    {
        $parts = explode('.', $key);
        $result = $this->settings[$parts[0]];

        for ($i = 1; $i < count($parts); ++$i) {
            $value = $parts[$i];

            if (is_array($result) && array_key_exists($value, $result)) {
                $result = $result[$value];
                continue;
            }

            $result = null;
            break;
        }

        return $result;
    }
1184358
public function getFieldByKey($key)
    {
        foreach ($this->groups as $group) {
            foreach ($group->getFields() as $field) {
                if ($field->getKey() == $key) {
                    return $field;
                }
            }
        }
    }
277477
public function getBindingCallback($key)
    {
        if (isset($this->binders[$key = str_replace('-', '_', $key)])) {
            return $this->binders[$key];
        }
    }
215345
public function findItemByKey(string $key)
    {
        return $this->items->first(function (BaseItem $item, $index) use ($key) {
            return $item->getKey() == $key;
        });
    }
912292
public function getDataset($key)
    {
        $data = $this->session->get(self::KEY);
        $set = isset($data[$key])
            ? $data[$key]
            : [];
        return $set;
    }
1268405
public function getMinified(string $key): ?string
    {
        if (array_key_exists($key, $this->map)) {
            return $key;
        }

        $foundKey = array_search($key, $this->map);
        if ($foundKey === false) {
            throw new JoryException('Key '.$key.' is no valid Jory key.');
        }

        return $foundKey;
    }
1364128
private static function getNumericKeyValue($key)
    {
        $newKey = \str_replace('np_serializer_element_', '', $key);
        list($type, $index) = \explode('_', $newKey);

        if ('integer' === $type) {
            $index = (int) $index;
        }

        return $index;
    }
286078
public function getAbsoluteConfigKey($key) {
        $prefix = null;
        $parser = $this->getConfigParser();
        $steps = explode('.', $key);
        $config = $this->config;

        foreach ($steps as $step) {
            if ( ! is_array($config)) {
                break;
            }

            array_shift($steps);
            $config = array_get($config, $step);

            if ($parser->isReference($config)) {
                array_unshift($steps, $parser->parseReferencePath($config));
                $config = implode('.', $steps);

                return $this->getAbsoluteConfigKey($config);
            }
        }

        return $key;
    }
1199367
private function lookupKey($key)
    {
        foreach ($this->pairs as $pair) {
            if ($this->keysAreEqual($pair->key, $key)) {
                return $pair;
            }
        }
    }
215191
public static function getColumnMap($key=NULL)
    {
        if ($key) {
            return isset(self::$_keyColumnMap[$key]) ? self::$_keyColumnMap[$key] : NULL;
        } else {
            return self::$_keyColumnMap;
        }
    }
61656
private function getArrayKey($key)
    {
        $data = $this->__toArray();

        $cases = [
            $key,
            $this->snakeCase($key),
            lower($this->snakeCase($key)),
            $this->camelCase($key),
            $this->kebabCase($key),
            lower($this->kebabCase($key)),
            $this->stringCase($key),
            lower($this->stringCase($key)),
            lower($key),
        ];

        $data = $this->filter(function ($value, $key) use ($cases) {
            return array_search($key, $cases) !== false ||
                array_search(lower($key), $cases) !== false;
        })
            ->keys()
            ->first();

        return is_string($data) ? $data : static::NOT_FOUND;
    }
1002567
public function get($key)
    {
        $value = $this->apc->get($this->prefix.$key);

        if ($value !== false) {
            return $value;
        }
    }
1037708
public function getSlot($key)
    {
        foreach ($this->slots as $slot) {
            if ($slot->getKey() === $key) {
                return $slot;
            }
        }

        return null;
    }
1160528
protected function getIndex($key)
    {
        $index = array_search($key, $this->keys, true);

        if ($index === false) {
            throw new \InvalidArgumentException("Index not found in map keys");
        }

        return $index;
    }
126940
public static function map(string $key = '')
    {
        $ref = new \ReflectionClass(static::class);

        $value = $ref->getConstant($key);

        return $ref->getConstant('_LIST')[$value] ?? '';
    }
1034276
protected function findLine($key)
    {
        $parsedKey   = null;
        $parsedValue = null;

        foreach ($this->lines as $index => $line) {
            $parseOk = $this->parseEnvLine($line, $parsedKey, $parsedValue);
            if ($parseOk && $key === $parsedKey) {
                return $index;
            }
        }

        return -1;
    }