Get the current value of the iterator
@return object
4831
public function getCurrent()
	{
		if ( ! $this->iterationStarted || is_null( $this->current ) )
			throw new InvalidOperationException();
		return $this->current->Current;
	}
388011
public function current()
    {
        $keys = array_keys($this->tags);
        return $this->tags[$keys[$this->position]];
    }
1149432
public function current()
    {
        $offset = 0;

        foreach ($this->observer as $observer) {
            if ($offset === $this->position) {
                return $observer;
            }
            ++$offset;
        }
    }
55704
public function getIterator()
    {

        $result = $this->data !== null ? $this->data : call_user_func($this->getter);

        if (!$result) {
            return new ArrayIterator([]);
        }

        if ($result instanceof Iterator) {
            return $result;
        }

        if (is_array($result)) {
            return new ArrayIterator($result);
        }

        if (!$result instanceof Traversable) {
            throw new UnexpectedValueException('The returned result of the assigned callable is not supported (traversable)');
        }

        $array = [];

        foreach ($result as $item) {
            $array[] = $item;
        }

        return new ArrayIterator($array);
    }
959091
public function current()
    {
        if (!$this->valid()) {
            return null;
        }

        $index = $this->index;
        $front = $this->front;
        $cap = $this->cap;
        $offset = ($index + $front) % $cap;

        return $this->items[$offset];
    }
396349
public function getValue() {
        if($this->input->old($this->getMeta()->name)) {
            return $this->getMeta()->getType()->transformInput($this->getMeta(), $this->input->old($this->getMeta()->name));
        } else {
            if($this->value !== null) {
                return parent::getValue();
            } else {
                return null;
            }
        }
    }
470198
public function current()
    {
        return isset($this->mappedEnums[$this->iteratorIndex])
            ? $this->valueMap[$this->mappedEnums[$this->iteratorIndex]->getConstName()]
            : null;
    }
491862
public function current()
    {
        if ($this->buffer === null) {
            $this->buffer = -2; // implicitly disable buffering from here on
        } elseif (is_array($this->buffer) && isset($this->buffer[$this->position])) {
            return $this->buffer[$this->position];
        }
        $data = $this->dataSource->current();
        
        if (is_array($this->buffer)) {
            $this->buffer[$this->position] = $data;
        }
        
        if ($this->returnType === self::TYPE_ARRAYOBJECT && is_array($data)) {
            $ao = clone $this->arrayObjectPrototype;
            if ($ao instanceof ArrayObject || method_exists($ao, 'exchangeArray')) {
                if ($ao instanceof AbstractModel) {
                    if(null === $this->array_prefix) {
                        $tab = [];
                        foreach ($data as $k => $v){
                            if(strpos($k, '$')!==false) {
                                $tab[] = explode('$', $k)[0];
                            }
                        }
                        $this->array_prefix = array_unique($tab);
                    }
                    $ao->setArrayPrefix($this->array_prefix);
                }
                $ao->exchangeArray($data);
            }
            $data = $ao;
        }
            
        if ($this->bufferArrayObjectPrototype && $this->buffer[$this->position] !== $data) {
            $this->buffer[$this->position] = $data;
        }

        return $data;
    }
650832
public function current()
    {
        if ($this->currentLine === null) {
            $this->readLine();
        }

        try {
            $data = $this->parser->parseLine($this->currentLine);
        } catch (MatchException $exception) {
            $data = null;
        }

        return $data;
    }
816483
public function current()
    {
        return array_key_exists($this->currentKey, $this->items)
            ? $this->items[$this->currentKey]
            : null;
    }
964112
public function current()
    {
        $row = parent::current();

        if (!$this->_validValues) {
            return $row;
        }

        $pointer =& $row;
        foreach ($this->_path as $step) {
            if (!isset($pointer[$step])) {
                return $row;
            }
            $pointer =& $pointer[$step];
        }

        $pointer[$this->_target] = $this->_values->current();

        return $row;
    }
1055063
public function current()
    {
        $rowDataForRowToBeProcessed = $this->rowDataBuffer;

        if ($this->shouldPreserveEmptyRows) {
            // when we need to preserve empty rows, we will either return
            // an empty row or the last row read. This depends whether the
            // index of last row that was read matches the index of the last
            // row whose value should be returned.
            if ($this->lastRowIndexProcessed !== $this->nextRowIndexToBeProcessed) {
                // return empty row if mismatch between last processed row
                // and the row that needs to be returned
                $rowDataForRowToBeProcessed = [''];
            }
        }

        return $rowDataForRowToBeProcessed;
    }
639857
public function current()
    {
        $row = null;

        if ($this->valid()) {
            $row = $this->getRowData($this->index);
        }

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

        return isset($this->items[$currentKey]) ? $this->items[$currentKey] : null;
    }
201690
public function current() {
    if ($this->position >= $this->length) {
      return NULL;
    }
    return $this->tokens[$this->position];
  }
218792
public function getCurrent()
    {
        if (is_null($this->current))
        {
            $siteView = $this->makeNewViewModel();

            $this->current = $siteView;
        }

        return $this->current;
    }
931021
public function getCurrent()
    {
        if ($this->_current === null) {
            $this->_current = $this->resolveCurrent();
            $this->trigger(self::EVENT_AFTER_RESOLVE_CURRENT);
        }

        return $this->_current;
    }