Returns the data of the current cache entry pointed to by the cache entry
iterator.

@return mixed
@api
961090
public function current()
    {
        if ($this->cacheFilesIterator === null) {
            $this->rewind();
        }

        $pathAndFilename = $this->cacheFilesIterator->getPathname();
        return $this->readCacheFile($pathAndFilename);
    }
655188
final public function current()
    {
        if ($this->position === -1) {
            $this->next();
        }

        Util::ensure(
            true,
            array_key_exists($this->position, $this->results),
            '\OutOfBoundsException',
            ['Collection contains no element at current position']
        );

        return call_user_func_array($this->loader, [$this->results[$this->position]]);
    }
60568
private function _getCurrentData()
    {
        $cls = $this->_cls;
        if (!$this->_data) {
            $this->_data = $cls::executePrepared($this->_builder, $this->_vals);
        }
        return $this->_data->fetch(\PDO::FETCH_ASSOC);
    }
195126
public function getData()
	{
		if ($this->usePaginator()) {
			$iterator = (new Paginator($this->getQuery()))->getIterator();

			$data = iterator_to_array($iterator);
		} else {
			$data = $this->getQuery()->getResult();
		}

		$this->onDataLoaded($data);

		return $data;
	}
34797
public function getCurrentItems() {
		if ($this->_currentItems === null) {
			$offset = $this->_itemsPerPage * $this->_currentPage - $this->_itemsPerPage;
			
			$this->_currentItems = $this->getAdapter()->getItems($offset, $this->_itemsPerPage);
			
			if (! $this->_currentItems instanceof Traversable) {
				throw new RuntimeException('Data from an adapter must implement the "Traversable" interface');
			}
		}
		
		return $this->_currentItems;
	}
215241
public function getData()
    {
        $serviceRoute = $this->requestStack->getCurrentRequest()
                                           ->get('service');

        // Locate the model definition
        $model = $this->getAnalyticModel($serviceRoute);

        $cacheTime = $model->getCacheTime();
        $cacheKey = $this->getCacheKey($model);

        //Cached data if configured
        if ($cacheTime &&
            !$this->requestStack->getCurrentRequest()->headers->has($this->skipCacheHeaderName) &&
            $cache = $this->cacheProvider->fetch($cacheKey)
        ) {
            return $cache;
        }

        $data = $this->analyticsManager->getData($model, $this->getServiceParameters($model));

        if ($cacheTime) {
            $this->cacheProvider->save($cacheKey, $data, $cacheTime);
        }

        return $data;
    }
3709
public function current()
    {
        $keys = array_keys($this->items);
        $var = $this->items[$keys[$this->index]];

        return $var;
    }
705716
public function current()
        {
            $this->_sort();
            current($this->_index);
            $hash = key($this->_index);

            if (isset($this->_pages[$hash])) {
                return $this->_pages[$hash];
            } else {
                throw new Exception(
                        'Corruption detected in container; ' .
                        'invalid key found in internal iterator');
            }
        }
1286337
public function cache()
    {
        $this->cache->remember($this->getCacheKey(), $this->getCacheLifetime(), function () {
            return $this->scan();
        });
    }
81256
public function current()
    {
        if (isset($this->buffer[$this->position])) {
            return $this->buffer[$this->position];
        }
        $this->ensurePosition();
        $data = $this->resultSet->current();
        $this->buffer[$this->position] = $data;
        return $data;
    }
436900
public function current()
    {
        $data = current($this->data);
        return Query::createItemObject($data, $this->lang, $this->getLoadedModel($data['id']));
    }
281172
public function getIterator()
    {

        if ($this->iteratorCache) {
            return $this->iteratorCache;
        }

        $this->parseInputOnce();

        $this->iteratorCache = $this->createTraversable($this->filters, $this->sorting(), $this->queryKeys());

        return $this->iteratorCache;
    }
697936
public function current()
    {
    	$data = $this->dbi->current();
		$class_name = $this->__class_name;
		$object = new $class_name($data['id']);
//		$object->set_id($data['id']);
		$object->data = $data;
		$object->set_is_loaded(true);
		return $object;
    }
978065
public function getCachedContent()
    {
        if ($this->_content !== null) {
            return $this->_content;
        }

        $this->_content = false;

        if (!($this->cache instanceof CacheInterface)) {
            return $this->_content;
        }

        $key = $this->calculateKey();
        $data = $this->cache->get($key);
        if (!is_array($data) || count($data) !== 2) {
            return $this->_content;
        }

        [$this->_content, $placeholders] = $data;
        if (!is_array($placeholders) || count($placeholders) === 0) {
            return $this->_content;
        }

        $this->_content = $this->updateDynamicContent($this->_content, $placeholders, true);

        return $this->_content;
    }
1287237
public function data()
    {
        if ($this->cache)
        {
            if (!$this->cache->valid($this->slice))
            {
                $data = $this->build();
                $this->cache->save($this->slice, $data);
            }

            return require $this->cache->getCachePath($this->slice);
        }

        return $this->build();
    }
602696
private function getCached() {
        if (isset($_GET['noCache'])) return null;
        $cacheDir = DATA . 'select' . DIRECTORY_SEPARATOR;
        if (!is_dir($cacheDir)) mkdir($cacheDir, 0777, true);

        $cache = $cacheDir . base64_encode($this->getName()) . '.php';
        if (!is_readable($cache)) return null;
        $cached = include $cache;
        return $this->decode($cached[$this->encode($this->query . serialize($this->values))]);
    }
1080573
public function key(): string
    {
        if ($this->cacheEntriesIterator === null) {
            $this->rewind();
        }
        return $this->cacheEntriesIterator->key();
    }