Parse the rows looking for the header row and storing it locally

@param array $current
@param int   $key

@return bool
968510
public function handleHeaderRow(array $current, $key)
    {
        if ($key == $this->csvFormat->getHeaderRow() - 1) {
            if (count($current) > 1 || strlen($current[0]) > 0) {
                $this->headerRow = $current;
            }
        }
        return true;
    }
1364616
public function getConfigHeader($key)
    {
        $path = $this->getDir() . 'config/header/' . $key . '.conf.php';
        if (is_readable($path) && is_file($path)) {
            return file_get_contents($path);
        }
        return null;
    }
439755
public function has(string $key): bool
    {
        $key = $this->getKey($key, true);
        return isset($this->headers[$key]);
    }
861960
protected function arrayHasKey(&$source, $key)
    {
        if (!$key || !is_array($source)) {
            return false;
        }

        if (array_key_exists($key, $source)) {
            return true;
        }

        $current =& $source;
        foreach (explode('.', $key) as $segment) {
            if (!array_key_exists($segment, $current)) {
                return false;
            }
            $current =& $current[$segment];
        }

        return true;
    }
485693
public function get($key)
    {
        $this->initialize();

        $ids = explode('.', $key);
        $base = &$this->data;

        while ($current = array_shift($ids)) {
            if (is_array($base) && array_key_exists($current, $base)) {
                $base = &$base[$current];
            } else {
                return null;
            }
        }

        return $base;
    }
1356874
public function read($key)
    {
        $key = $this->_key($key);

        if (!$this->_init || $this->_setKey($key) === false) {
            return false;
        }

        if ($this->_config['lock']) {
            $this->_File->flock(LOCK_SH);
        }

        $this->_File->rewind();
        $time = time();
        $cachetime = (int)$this->_File->current();

        if ($cachetime < $time) {
            if ($this->_config['lock']) {
                $this->_File->flock(LOCK_UN);
            }

            return false;
        }

        $data = '';
        $this->_File->next();
        while ($this->_File->valid()) {
            $data .= $this->_File->current();
            $this->_File->next();
        }

        if ($this->_config['lock']) {
            $this->_File->flock(LOCK_UN);
        }

        $data = trim($data);

        if ($data !== '' && !empty($this->_config['serialize'])) {
            if ($this->_config['isWindows']) {
                $data = str_replace('\\\\\\\\', '\\', $data);
            }
            $data = unserialize((string)$data);
        }

        return $data;
    }
924866
protected function hasHeader(array $headers, string $key):bool{
		$lowercaseHeader = \strtolower($key);

		foreach($headers as $k => $v){
			if(\strtolower($k) === $lowercaseHeader){
				return true;
			}
		}

		return false;
	}
1274144
public function read($key)
    {
        $result = $this->mongoInstance->findOne(self::collection, ['key' => $key]);

        if (is_array($result) && isset($result['content'])) {
            $this->remainingTtl = $result['ttl']->toDateTime()->getTimestamp() - time();

            return $result['content'];
        }

        $this->remainingTtl = 0;
        return false;
    }
295874
public function __isset($key)
	{
		if (!$this->_isParsed)
		{
			$this->_parseData();
			$this->_isParsed = true;
		}

		return isset($this->_parsedData->$key);
	}
536054
public Object get(Object key) {
        checkThread();
        return current == null ? null : current.get(key);
    }
314263
public function remove($key): bool {
        /** @var \doganoo\PHPAlgorithms\Datastructure\Lists\Node $previous */
        $previous = $head = $this->getHead();
        if ($head === null) {
            return true;
        }
        $i = 1;
        $headSize = $head->size();

        /*
         * The while loop iterates over all nodes until the
         * value is found.
         */
        while ($head !== null && $head->getKey() !== $key) {
            /*
             * since a node is going to be removed from the
             * node chain, the previous element has to be
             * on hold.
             * After previous is set to the actual element,
             * the current element pointer can moved to the
             * next one.
             *
             * If the value is found, $previous points to
             * the previous element of the value that is
             * searched and current points to the next element
             * after that one who should be deleted.
             */
            $previous = $head;
            $head = $head->getNext();
            $i++;
        }

        /*
         * If the value that should be deleted is not in the list,
         * this set instruction assigns the next node to the actual.
         *
         * If the while loop has ended early, the next node is
         * assigned to the previous node of the node that
         * should be deleted (if there is a node present).
         */
        if ($head !== null) {
            $previous->setNext($head->getNext());
        }
        return $i !== $headSize;
    }
1181595
public function has($key) {
        if (is_array($key)) {
            $key = $key['key'];
        }
        return isset($this->store[$key]);
    }
939566
public function find($key, $default = null) {
        $key = $this->formatKey($key);
        $headers = array_get($this->headers, $key, $default);

        if (is_array($headers)) {
            $headers = array_pop($headers);
        }

        return $headers;
    }
1323225
public function get($key = null)
    {
        if (!isset($this->list[$key])) return null;
        $this->currentIdentifier = $this->cacheListing[$key]->getId();

        return $this->list[$key];
    }
896222
public function getObjectByKey($key)
       {
            if (isset($this->map[$key])) {
                parent::rewind();
                while(parent::valid()) {
                    if (parent::key() === $key) {
                        return parent::current();
                    }
                    parent::next();
                }
            }
       }
427463
public function to($key)
    {
        $getter = 'get'.ucfirst($key);
        $hasser = 'has'.ucfirst($key);
        $isser  = 'is'.ucfirst($key);

        if (is_array($this->current) && array_key_exists($key, $this->current)) {
            $this->current = &$this->current[$key];
        } elseif ($this->isObjectWithMethod($this->current, $key)) {
            $this->current = $this->current->$key();
        } elseif ($this->isObjectWithMethod($this->current, $getter)) {
            $this->current = $this->current->$getter();
        } elseif ($this->isObjectWithMethod($this->current, 'get')) {
            $this->current = $this->current->get($key);
        } elseif ($this->isObjectWithMethod($this->current, $hasser)) {
            $this->current = $this->current->$hasser();
        } elseif ($this->isObjectWithMethod($this->current, 'has')) {
            $this->current = $this->current->has($key);
        } elseif ($this->isObjectWithMethod($this->current, $isser)) {
            $this->current = $this->current->$isser();
        } elseif ($this->isObjectWithMethod($this->current, 'is')) {
            $this->current = $this->current->is($key);
        } elseif (is_object($this->current) && isset($this->current->$key)) {
            $this->current = $this->current->$key;
        } else {
            return false;
        }

        return true;
    }
472466
public function has($key)
    {
        $key = $this->parseKey($key);

        $string = $key->shift();
        $key->next();

        if ($key->count() === 0) {
            return array_key_exists($string, $this->data);
        }

        if (! array_key_exists($string, $this->data)) {
            return false;
        }

        $value = $this->getValue($string);

        // #TODO Handle other objects and arrays
        if (! $value instanceof Accessable) {
            //throw new AccessException('The existance for the key "' . $key->raw . '" could\'nt be checked.');
            return false;
        }

        return $value->has($key);
    }