@return \RecursiveIterator

@throws AccessDeniedException
187367
public function getChildren()
    {
        try {
            $children = parent::getChildren();

            if ($children instanceof self) {
                // parent method will call the constructor with default arguments, so unreadable dirs won't be ignored anymore
                $children->ignoreUnreadableDirs = $this->ignoreUnreadableDirs;

                // performance optimization to avoid redoing the same work in all children
                $children->rewindable = &$this->rewindable;
                $children->rootPath = $this->rootPath;
            }

            return $children;
        } catch (\UnexpectedValueException $e) {
            if ($this->ignoreUnreadableDirs) {
                // If directory is unreadable and finder is set to ignore it, a fake empty content is returned.
                return new \RecursiveArrayIterator(array());
            } else {
                throw new AccessDeniedException($e->getMessage(), $e->getCode(), $e);
            }
        }
    }
222351
public function getIterator()
    {
        $aResult = array();
        $iStart  = ($this->itemsPerPage * ($this->page - 1));
        if ($iStart < 0) {
            throw new \OutOfBoundsException('Start index cant no be lower then 1');
        }
        try {
            $iRestOfResults                    = ($this->itemsPerPage - 1);
            $mFirstValues                      = $this->collection->seek($iStart);
            $aResult[$this->collection->key()] = $mFirstValues;
            while ($iRestOfResults > 0) {
                $mValue = $this->collection->scNext();
                if ($mValue === AbstractCollection::NOT_SET_FLAG) {
                    throw new \OutOfBoundsException();
                }
                $aResult[$this->collection->key()] = $mValue;
                $iRestOfResults--;
            }

        } catch (\OutOfBoundsException $oException) {
            // do nothing, this exception is not critical
        }
        $sClassName = get_class($this->collection);

        return new $sClassName($aResult);
    }
429268
public function getIterator(): \Traversable
    {
        $routes = $this->routes;
        usort(
                $routes,
                function(Route $a, Route $b)
                {
                    return strnatcmp($a->configuredPath(), $b->configuredPath());
                }
        );
        return new \ArrayIterator($routes);
    }
766553
public function getIterator()
    {
    	if ($this->sortedIterator === null) {
    	    if ($this->cloneItems) {
    	        $array = array();
                foreach ($this->originalIterator as $key => $value) {
                    $array[$key] = clone $value;
                }
            } else {
    	        $array = iterator_to_array($this->originalIterator);
    	    }
    	    $this->sort($array);
    	    $this->sortedIterator = new \ArrayIterator($array);
    	}
    	return $this->sortedIterator;
    }
1301732
public function flattenRecursive()
    {
        $flat = array();

        foreach (new \RecursiveIteratorIterator(new \RecursiveArrayIterator($this)) as $value) {
            $flat[] = $value;
        }

        return $flat;
    }
8135
public function getIterator()
    {
        $array = [];
        foreach (array_keys($this->imports) as $group) {
            $array[$group] = $this->offsetGet($group);
        }

        return new ArrayIterator($array);
    }
1094082
private function getIterator()
    {
        if (null === $this->getPath()) {
            throw new \RuntimeException('Commands config path not set');
        }
        if (null === $this->it) {
            $this->it =  new \DirectoryIterator($this->getPath());
        }
        return $this->it;
    }
950136
public function getIterator(): \Traversable
    {
        $result = [];
        foreach ($this->links as $link) {
            if (is_array($link)) {
                $result = array_merge($result, $link);
            } else {
                $result[] = $link;
            }
        }

        return new \ArrayIterator($result);
    }
43225
public function getIterator()
    {
        // Return an iterator just like the old iteration of the HistoryPlugin for BC compatibility (use getAll())
        return new \ArrayIterator(array_map(function ($entry) {
            $entry['request']->getParams()->set('actual_response', $entry['response']);
            return $entry['request'];
        }, $this->transactions));
    }
685839
public function getChildren()
    {
        $current = $this->current();
        $key = $this->key();
        $unfolder = $this->_unfolder;

        return new NoChildrenIterator($unfolder($current, $key, $this->_innerIterator));
    }
940201
private function getPartHeadersIterator()
    {
        if ($this->part instanceof ParentHeaderPart) {
            return $this->part->getRawHeaderIterator();
        } elseif ($this->part->getParent() !== null && $this->part->getParent()->isMime()) {
            return new ArrayIterator([
                [ 'Content-Type', $this->part->getContentType() ],
                [ 'Content-Disposition', $this->part->getContentDisposition() ],
                [ 'Content-Transfer-Encoding', $this->part->getContentTransferEncoding() ]
            ]);
        }
        return new ArrayIterator();
    }
375812
protected function _getIterator()
    {
        foreach(array_keys($this->properties) as $key)
            yield $key => $this->__get($key);
    }
937852
public function getIterator()
    {
        $recordData = [
            'loggerName' => $this->getLoggerName(),
            'message'    => $this->getMessage(),
            'level'      => $this->getLevel(),
            'context'    => $this->getContext(),
            'datetime'   => $this->getDatetime(),
            'extra'      => $this->getExtra()
        ];

        return new \ArrayIterator($recordData);
    }
616992
public function getIterator()
    {
        $array = $this->getArrayCopy();

        // Is the collection nested in the array?
        if (isset($this->collectionProperty)) {

            // Locate the collection in the response.
            $collectionFound = false;
            $property = NULL;
            foreach ((array) $this->collectionProperty as $property) {
                if (isset($array[$property])) {
                    $collectionFound = true;
                    break;
                }
            }

            if (!$collectionFound) {
                throw new \OutOfBoundsException('Collection not found in response');
            }

            $array = $array[$property];
        }

        // Build the collection.
        $collection = array();
        foreach ($array as $item) {
            $element = new $this->elementClass($item);
            $collection[(string) $element] = $element;
        }

        return new \ArrayObject($collection);
    }
1065544
public function getIterator()
    {
        $tagsById       = $this->container->findTaggedServiceIds($this->tag);
        $taggedServices = array();
        foreach ($tagsById as $id => $tagDefinitions) {
            /* @var $id string */
            /* @var $tagDefinitions array(array(string=>string)) */
            foreach ($tagDefinitions as $tagDefinition) {
                /* @var $tagDefinition array(string=>string) */
                $taggedServices[] = new TaggedService($id, $tagDefinition);
            }
        }
        return new \ArrayIterator($taggedServices);
    }
496845
public function getIterator()
    {
        $this->kernel->boot();
        $viewDirectories = $this->getPossibleViewDirectories();
        $viewDirectories = $this->removeNotExistingDirectories($viewDirectories);
        $templates       = $this->getTwigTemplatesIn($viewDirectories);
        return new \ArrayIterator($templates);
    }
1308119
public function indexAction()
    {
        $tools = $this->toolManager->getAdminToolsByRoles($this->tokenStorage->getToken()->getRoles());

        if (count($tools) === 0) {
            throw new AccessDeniedException();
        }

        return $this->redirect($this->generateUrl('claro_admin_open_tool', array('toolName' => $tools[0]->getName())));
    }