Return the current element

@link    http://php.net/manual/en/iterator.current.php
@return  Structure
332523
public function current()
    {
        $name = $this->key();

        if ( $name )
        {
            return $this->getMapper()
                        ->find( $name );
        }

        return null;
    }
1001781
public function current()
    {
        $currentKey = $this->keys[$this->position];

        return isset($this->items[$currentKey]) ? $this->items[$currentKey] : null;
    }
251175
private function getCurrentItem()
    {
        // Hack for weird initialization logic
        if (!$this->currentItem) {
            $key = $this->getCurrentKey();
            $this->currentItem = $this->getItemStorage()->get($key);
        }

        return $this->currentItem;
    }
411536
public function current()
    {
        $line = fgets($this->handle);
        $this->length = strlen($line);
        fseek($this->handle, $this->offset);

        return $line;
    }
1109494
public function current()
    {
        $row = null;

        if ($this->valid()) {
            /* @var $schemaManager SchemaManager */
            $schemaManager = $this->schemaManager;

            $schemas = $schemaManager->listSchemas();

            $schema = $schemas[$this->index];

            $row = [
                'CATALOG_NAME' => null,
                'SCHEMA_NAME' => $schema,
                'DEFAULT_CHARACTER_SET_NAME' => null,
                'DEFAULT_COLLATION_NAME' => null,
                'SQL_PATH' => null,
            ];
        }

        return $row;
    }
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;
    }
503167
public function current()
    {
        if (false !== $this->value) {
            return $this->value;
        }

        $this->value = $this->getCurrentRecord();

        return $this->value;
    }
799797
def get_current_structure(self):
        

        struct = self.__class__.get_structure()
        struct.update(self.__field_types__)
        return struct
980040
public function current()
    {
        if (is_callable($this->currentCallback)) {
            $return = call_user_func($this->currentCallback, parent::current());
            return $return;
        } else {
            return parent::current();
        }
    }
932181
public function current()
    {
        list($name, $content) = $this->members[$this->pointer];
        if (is_a($content, ViewHelperInterface::class)) {
            /** @var $content ViewHelperInterface */
            return $content->__toString();
        }
        switch ($name) {
            case 'charset':
                return "<meta {$name}=\"{$content}\">";
            case 'base':
                return "<base href=\"{$content}\" />";
            default:
                return "<meta name=\"{$name}\" content=\"{$content}\">";
        }
    }
931021
public function getCurrent()
    {
        if ($this->_current === null) {
            $this->_current = $this->resolveCurrent();
            $this->trigger(self::EVENT_AFTER_RESOLVE_CURRENT);
        }

        return $this->_current;
    }
1046854
public function current()
	{
		$row = fgetcsv($this->file, self::ROW_LENGTH, $this->delimiter);
		$this->position++;

		// store headers for later
		if ($this->position == 1)
		{
			$this->headers = $row;
		}

		// return null for the first row and last row if empty
		// we dont want to count the headings row
		if ($this->position == 1 || $row === false)
		{
			return null;
		}

		// map headings
		$object = new stdClass;
		foreach ($this->headers as $k => $header)
		{
			$header = trim($header);
			$header = trim($header, ':');
			$header = ($header ?: 'COLUMN');

			// If a column header contains a colon, we break it
			// into a sub-object with properties.
			//
			// Address:street, Address:city
			//  ->  Address => { street = data, city = data }
			//
			if (strpos($header, ':'))
			{
				$parts = explode(':', $header);

				// Make sure we have more than one part
				if (count($parts) > 1)
				{
					if (!isset($object->{$parts[0]}) || !is_object($object->{$parts[0]}))
					{
						$object->{$parts[0]} = new stdClass;
					}
					$object->{$parts[0]}->{$parts[1]} = $row[$k];
				}
				else
				{
					$object->$header = $row[$k];
				}
			}
			else
			{
				$object->$header = $row[$k];
			}
		}

		// return as object
		return $object;
	}
495006
public function current()
    {
        $port = Current::port();
        if (! $port || ! $prefix = $port->prefix()) {
            return $this->to($this->request->getPathInfo());
        }

        return $this->to($this->getPathInfo());
    }
195128
public function current()
    {
        if ($this->valid()) {
            $key = $this->baseArrayMap[$this->iteratorIterationPosition];
            $value = $this->baseConcreteData[$key];
            return $this->internalFilterHooks($key, $value, 'output') ?
                $this->internalSanitizeHooks($key, $value, 'output') : null;
        }
    }
961090
public function current()
    {
        if ($this->cacheFilesIterator === null) {
            $this->rewind();
        }

        $pathAndFilename = $this->cacheFilesIterator->getPathname();
        return $this->readCacheFile($pathAndFilename);
    }
871898
function current()
	{
		$sheet = $this->_iterator->current();

		return new MW_Container_Content_PHPExcel( $sheet, $sheet->getTitle(), $this->_getOptions() );
	}
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]]);
    }