Returns all Kwc_Root_Category_Generators used.

the name of this method is a bit missleading

@return Kwc_Root_Category_Generator[]
771478
public function getPageGenerators()
    {
        if (!is_null($this->_pageGenerators)) return $this->_pageGenerators;

        $cacheId = $this->componentClass . '_pageGenerators';

        $generators = Kwf_Cache_SimpleStatic::fetch($cacheId);
        if (!$generators) {
            $generators = array();
            foreach (Kwc_Abstract::getComponentClasses() as $class) {
                foreach (Kwc_Abstract::getSetting($class, 'generators') as $key => $generator) {
                    if (!isset($generator['class'])) {
                        throw new Kwf_Exception("no generator class set for generator '$key' in component '$class'");
                    }
                    if (is_instance_of($generator['class'], 'Kwc_Root_Category_Generator')) {
                        $generators[] = array('class' => $class, 'key' => $key, 'generator' => $generator);
                    }
                }
            }
            Kwf_Cache_SimpleStatic::add($cacheId, $generators);
        }

        $this->_pageGenerators = array();
        foreach ($generators as $g) {
            $this->_pageGenerators[] = Kwf_Component_Generator_Abstract::getInstance(
                $g['class'], $g['key'], $g['generator']
            );
        }
        return $this->_pageGenerators;
    }
283411
public function getAllChildren() {
    // Define as array.
    $options = [];

    // Fetch main categories.
    foreach (array_keys($this->getCategories()) as $category) {
      $options = array_merge($options, $this->getChildren($category));
    }
    // Return array.
    return $options;
  }
461866
private function directories(): \Generator
    {
        foreach ($this->directories as $root) {
            if (is_dir($root)) {
                yield $root => new \RecursiveIteratorIterator(
                    new \RecursiveDirectoryIterator($root)
                );
            }
        }
    }
1017640
private function generateCategoryRules()
	{
		$rules = array();
		$categories = Categories::model()->findAll();
		foreach ($categories as $el)
		{
			if ($el->slug == NULL)
				continue;

			$pageRule = $el->slug.'/<page:\d+>';
			$rule = $el->slug;

			$pageRule = $el->slug . '/<page:\d+>';
			$rule = $el->slug;

			$rules[$pageRule] = "categories/index/id/{$el->id}";
			$rules[$rule] = "categories/index/id/{$el->id}";
		}

		return $rules;
	}
1249919
public String[] getGeneratorFunctions()
    {
    String[] functions = new String[ generators_.size()];
    generators_.keySet().toArray( functions);
    return functions;
    }
882016
public function getCategories()
    {
        $categoryEntities = $this->entity->getCategories();

        $categories = [];
        if ($categoryEntities) {
            foreach ($categoryEntities as $categoryEntity) {
                $categories[] = new Category($categoryEntity, $this->locale);
            }
        }

        return $categories;
    }
59844
public function getCategoryIds()
    {
        return array_keys((new CmsCategoryRelationQuery)
                ->join('cms_category')->on('cms_category_id')
                ->whereObject()->equals($this->_object)
                ->andFieldObjectId()->equals($this->_objectId)
                ->findPairs('cms_category.id', 'cms_category.id'));
    }
302884
public Iterator
generators() {
	if (generators != null)
		return Collections.unmodifiableList(generators).iterator();
	else
		return Collections.EMPTY_LIST.iterator();
}
773559
protected function children() : array
	{
		$categories = App::make('category.repository.cahe')->childrenOf($this->category_id, 50, [
			'id', 'category_id', 'name'
		]);

		return Normalizer::generation($categories)
        	->prepend((int) $this->category_id)
        	->all();
	}
1365787
public function get_categories() {
        $data = $this->data;

        if (empty($data[Parser::INDEX_PARENT_SPEC])) {
            return array();
        }

        // Okay. We first grab all of our categories.
        $categories = array();
        foreach ($data[Parser::INDEX_PARENT_SPEC] as $category) {
            $categories[] = $this->api->get_category($category['value']);
        }

        return $categories;
    }
1289384
public IntList getRoots() {
    IntList roots = new IntArrayList();
    for(int i = 0; i < used; i++) {
      // roots or one element in component
      if(parent[i] == i) {
        roots.add(i);
      }
    }
    return roots;
  }
61592
protected function getAllBaseNames()
    {
        $pluggables = [];

        $path = $this->getPath();

        if (!is_dir($path)) {
            return $pluggables;
        }

        $folders = $this->files->directories($path);

        foreach ($folders as $plug) {
            $pluggables[] = basename($plug);
        }

        return $pluggables;
    }
675306
protected function detectDirectoryDescendants()
    {
        $descendants = [];

        foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->getPath())) as $file) {
            if ($file->isDir() && ! in_array($file->getBasename(), array('.', '..'))) {
                $resource = new DirectoryResource($file, $this->files);

                $descendants[$resource->getKey()] = $resource;
            } elseif ($file->isFile()) {
                $resource = new FileResource($file, $this->files);

                $descendants[$resource->getKey()] = $resource;
            }
        }

        return $descendants;
    }
536488
public function getSubstitutionGroups()
	{
		$usedGroups = array_reduce( $this->elements, function( $carry, $element ) {

			foreach ( $element as $key => $entry )
			{
				$group = $entry['taxonomy_element']['substitutionGroup'];
				if ( ! isset( $carry[ $group ] ) )
					$carry[ $group ] = 1;
			}

			return $carry;
		}, array() );

		return array_keys( $usedGroups );
	}
421100
public function getExcludedSiteTreeClassNames() {
		$classes = array();
		$siteTreeClasses = $this->owner->allowedChildren();
		foreach($siteTreeClasses as $class) {
			if(Injector::inst()->create($class)->config()->show_in_sitetree === false) {
				$classes[$class] = $class;
			}
		}
		return $classes;
	}
956091
public static function getRootCategories()
    {
        $app = App::getInstance();

        $sql = $app['safesql']->query(
            "SELECT
				`id`
			FROM `category`
			WHERE hidden = 0
			AND id > 0
			AND parent IS NULL
			AND deleted = 0
			ORDER BY `order` ASC",
            array());
        $results = $app['db']->get_results($sql);
        $cats = array();

        if (!is_null($results)) {
            foreach ($results as $cat) {
                $cats[] = new Category($cat->id);
            }
        }
        return $cats;
    }
233803
public function getRootNodes()
	{
		$searchCondition = $this->createSearchCondition();
		$searchCondition->levelEqualsTo(0);

		$rootNodes = $this->search($searchCondition);
		return $rootNodes;
	}