Try to index the entire map

@return void
435822
public function Index($ExtraPaths = NULL) {
      
      $FileMasks = array(
         sprintf(self::LOOKUP_CLASS_MASK, '*'),
         sprintf(self::LOOKUP_INTERFACE_MASK, '*')
      );
      
      $ExtraPathsRemove = NULL;
      if (!is_null($ExtraPaths)) {
         $ExtraPathsRemove = array();
         foreach ($ExtraPaths as $PathOpts) {
            $ExtraPath = GetValue('path', $PathOpts);
            if (array_key_exists($ExtraPath, $this->Paths)) continue;
            
            $ExtraPathsRemove[] = $ExtraPath;
            $ExtraOptions = $this->BuildOptions;
            $ExtraOptions['SplitTopic'] = GetValue('topic', $PathOpts);
            $this->AddPath($ExtraPath, $ExtraOptions);
         }
      }
      
      foreach ($this->Paths as $Path => $PathOptions) {

         $Recursive = GetValue('recursive', $PathOptions);
         $Files = $this->FindFiles($Path, $FileMasks, $Recursive);
         if ($Files === FALSE) continue;
         
         foreach ($Files as $File) {
            $SplitTopic = GetValue('topic', $PathOptions, self::TOPIC_DEFAULT);
            
            $ProvidedClass = $this->GetClassNameFromFile($File);
            if ($ProvidedClass) {
               $this->Map[$SplitTopic][$ProvidedClass] = $File;
               $this->MapInfo['dirty'] = TRUE;
            }
               
//            $ProvidesClasses = $this->Investigate($File);
//            if ($ProvidesClasses === FALSE) continue;
//            
//            foreach ($ProvidesClasses as $ProvidedClass) {
//               $ProvidedClass = strtolower($ProvidedClass);
//               $this->Map[$SplitTopic][$ProvidedClass] = $File;
//               $this->MapInfo['dirty'] = TRUE;
//            }
         }
      }
      
      // Save
      $this->Shutdown();
      
      if (!is_null($ExtraPathsRemove))
         foreach ($ExtraPathsRemove as $RemPath)
            unset($this->Paths[$RemPath]);
   }
686506
public function loadIndexingProperties()
    {
        if ($this->indexingPropertiesLoaded) {
            return;
        }

        $indexingProperties = $this->indexQueueIndexingPropertyRepository->findAllByIndexQueueUid(intval($this->indexQueueUid));
        $this->indexingPropertiesLoaded = true;
        if (empty($indexingProperties)) {
            return;
        }

        foreach ($indexingProperties as $indexingProperty) {
            $this->indexingProperties[$indexingProperty['property_key']] = $indexingProperty['property_value'];
        }
    }
1252951
public function index() {

        /**
         * set lastUpdatedPage
         */
        $query = TableRegistry::get('CmsContent')->find();
        $query->where(['content_type' => 'page']);
        $query->order(['modified' => 'DESC']);
        $this->set('last_page', $query);

        /**
         * set lastUpdatedNews
         */
        $query = TableRegistry::get('CmsContent')->find();
        $query->where(['content_type' => 'news']);
        $query->order(['modified' => 'DESC']);
        $this->set('last_news', $query);

        /**
         * set view
         */
        $this->viewBuilder()->template('dashboard');
    }
1349017
public function index()
    {
        $tickets = $this->paginate($this->Tickets);

        $this->set(compact('tickets'));
        $this->set('_serialize', ['tickets']);
    }
274168
public function index() {
		$logs = [];
		$typesWithCount = $this->DatabaseLogs->getTypesWithCount();

		$lastErrors = $this->DatabaseLogs->find()
			->select(['summary'])
			->where(['type' => 'error'])
			->group('summary')
			->orderDesc('id')
			->limit(10)
			->disableHydration()
			->all()->toArray();

		$this->set(compact('logs', 'typesWithCount', 'lastErrors'));
	}
1158575
public function index()
    {
        $page = $this->request->getQuery('page', 1);

        //Sets the cache name
        $cache = sprintf('index_limit_%s_page_%s', $this->paginate['limit'], $page);

        //Tries to get data from the cache
        list($posts, $paging) = array_values(Cache::readMany(
            [$cache, sprintf('%s_paging', $cache)],
            $this->Posts->getCacheName()
        ));

        //If the data are not available from the cache
        if (empty($posts) || empty($paging)) {
            $posts = $this->paginate($this->Posts->find('active')->find('forIndex'));

            //Writes on cache
            Cache::writeMany([
                $cache => $posts,
                sprintf('%s_paging', $cache) => $this->request->getParam('paging'),
            ], $this->Posts->getCacheName());
        //Else, sets the paging parameter
        } else {
            $this->request = $this->request->withParam('paging', $paging);
        }

        $this->set(compact('posts'));
    }
765150
public function indexAction()
    {
        self::checkSignin();
        
        $this->view->setVars([
            'projects' => $this->projects,
            'bin' => $this->php,
            'dbs' => $this->dbs,
        ]);
    }
930096
public function index() {
        $this->Prg->commonProcess();
        $conds = $this->IvaResponsabilidad->parseCriteria( $this->Prg->parsedParams() );
        $this->Paginator->settings['conditions'] = $conds;
        $this->IvaResponsabilidad->recursive = 0;
        $ivaResponsabilidades = $this->Paginator->paginate('IvaResponsabilidad');
        $this->set('ivaResponsabilidades',$ivaResponsabilidades);
    }
1286149
public function index()
    {
        $query = $this->PostsTags->Tags->find()->matching('Posts');

        $this->paginate['order'] = ['tag' => 'ASC'];

        //Limit X4
        $this->paginate['limit'] = $this->paginate['maxLimit'] = $this->paginate['limit'] * 4;

        $tags = $this->paginate($this->PostsTags->Tags->queryFromFilter($query, $this->request->getQueryParams()));

        $this->set(compact('tags'));
    }
440954
protected function updateMapList()
    {
        $start = 0;

        do {
            try {
                $maps = $this->factory->getConnection()->getMapList(self::BATCH_SIZE, $start);
            } catch (IndexOutOfBoundException $e) {
                // This is normal error when we we are trying to find all maps and we are out of bounds.
                return;
            } catch (NextMapException $ex) {
                // this is if no maps defined
                return;
            }

            if (!empty($maps)) {
                foreach ($maps as $map) {
                    $this->mapStorage->addMap($map);
                }
            }

            $start += self::BATCH_SIZE;

        } while (count($maps) == self::BATCH_SIZE);
    }
641847
public function indexAction()
    {
        $typ = $this->request->get('typ', 'string');

        $data = [];
        if ( empty($typ) ) {
            $data = self::major(); 
        } else if ( method_exists(__CLASS__, $typ)
            && ! in_array($typ, parent::blacklist() )
        ) {
            $data = self::$typ();
        }

        $this->respond($data);

        // fastcgi_finish_request();

        // parent::spoor();
    }
936600
public function index()
    {
        if($this->presenter->page->file instanceof SplFileInfo) {
            $this->view->page(presenter()->page->file->getRealPath());
        }
    }
563297
protected function bindIndex()
    {
        $this->app->bind('iverberk.larasearch.index', function ($app, $params)
        {
            $name = isset($params['name']) ? $params['name'] : '';

            return new Index($params['proxy'], $name);
        });
    }
665055
public function indexAction()
    {
        if ($this->checkForAnswersOnLoad) {
            $this->loader->getTracker()->processCompletedTokens(
                    null,
                    $this->currentUser->getUserId(),
                    $this->currentUser->getCurrentOrganizationId(),
                    true
                    );
        }

        parent::indexAction();
    }
158562
public function index()
    {
        $this->request->allowMethod('get');

        $query = $this->SavedSearches->find('all')
            ->where(['name IS NOT' => null])
            ->where(['name !=' => ''])
            ->where($this->request->getQueryParams());

        $entities = $this->paginate($query);

        $this->set('success', true);
        $this->set('data', $entities);
        $this->set('_serialize', ['success', 'data']);
    }
1041315
public function deleteIndex()
    {
        foreach ($this->locales as $locale) {
            $this->searchProvider->deleteIndex($this->indexName . '_' . $locale);
        }
    }
185761
public function index()
    {
        $this->defaultData();
        $userLangService = $this->getServiceLocator()->get(UserLanguageServiceInterface::class);
        $this->setData('user-data-lang-enabled', $userLangService->isDataLanguageEnabled());
        $this->setView('user/list.tpl');
    }