Starts the process to load pages and saves the matching results.
974436
protected function _getURLs() {
		if ($this->_post) {
			$this->_sendPost();
		}
		if ($this->_fill_urls) {
			$this->_getFillURLs();
		}
		if (is_array($this->_urls) == false OR count($this->_urls) < 1) {
			return false;
		}
		foreach ($this->_urls as $name => $url) {
			$this->_setHTML($url);
			$this->_getMatch($name);
			$this->_getMatchAll($name);
		}
	}
133927
public void loadPages() {
        if (optimalPageWidth == 0 || optimalPageHeight == 0) {
            return;
        }

        // Cancel all current tasks
        renderingAsyncTask.removeAllTasks();
        cacheManager.makeANewSet();

        // Find current index in filtered user pages
        int index = currentPage;
        if (filteredUserPageIndexes != null) {
            index = filteredUserPageIndexes[currentPage];
        }

        // Loop through the pages like [...][4][2][0][1][3][...]
        // loading as many parts as it can.
        int parts = 0;
        for (int i = 0; i <= Constants.LOADED_SIZE / 2 && parts < CACHE_SIZE; i++) {
            parts += loadPage(index + i, CACHE_SIZE - parts);
            if (i != 0 && parts < CACHE_SIZE) {
                parts += loadPage(index - i, CACHE_SIZE - parts);
            }
        }

        invalidate();
    }
672960
private void run() {
        onStart();

        while (!isStopping && crawlFrontier.hasNextCandidate()) {
            CrawlCandidate currentCandidate = crawlFrontier.getNextCandidate();
            String candidateUrl = currentCandidate.getRequestUrl().toString();
            HttpClientContext context = HttpClientContext.create();
            CloseableHttpResponse httpHeadResponse = null;
            boolean isUnsuccessfulRequest = false;

            try {
                // Send an HTTP HEAD request to determine its availability and content type
                httpHeadResponse = getHttpHeadResponse(candidateUrl, context);
            } catch (IOException exception) {
                callbackManager.call(CrawlEvent.REQUEST_ERROR,
                        new RequestErrorEvent(currentCandidate, exception));
                isUnsuccessfulRequest = true;
            }

            if (!isUnsuccessfulRequest) {
                String responseUrl = getFinalResponseUrl(context, candidateUrl);
                if (responseUrl.equals(candidateUrl)) {
                    String responseMimeType = getResponseMimeType(httpHeadResponse);
                    if (responseMimeType.equals(ContentType.TEXT_HTML.getMimeType())) {
                        boolean isTimedOut = false;
                        TimeoutException timeoutException = null;

                        try {
                            // Open URL in browser
                            webDriver.get(candidateUrl);
                        } catch (TimeoutException exception) {
                            isTimedOut = true;
                            timeoutException = exception;
                        }

                        // Ensure the HTTP client and Selenium have the same state
                        syncHttpClientCookies();

                        if (isTimedOut) {
                            callbackManager.call(CrawlEvent.PAGE_LOAD_TIMEOUT,
                                    new PageLoadTimeoutEvent(currentCandidate, timeoutException));
                        } else {
                            String loadedPageUrl = webDriver.getCurrentUrl();
                            if (!loadedPageUrl.equals(candidateUrl)) {
                                // Create a new crawl request for the redirected URL (JS redirect)
                                handleRequestRedirect(currentCandidate, loadedPageUrl);
                            } else {
                                callbackManager.call(CrawlEvent.PAGE_LOAD,
                                        new PageLoadEvent(currentCandidate, webDriver));
                            }
                        }
                    } else {
                        // URLs that point to non-HTML content should not be opened in the browser
                        callbackManager.call(CrawlEvent.NON_HTML_CONTENT,
                                new NonHtmlContentEvent(currentCandidate, responseMimeType));
                    }
                } else {
                    // Create a new crawl request for the redirected URL
                    handleRequestRedirect(currentCandidate, responseUrl);
                }
            }

            HttpClientUtils.closeQuietly(httpHeadResponse);
            performDelay();
        }

        onStop();
    }
54134
public function pageStart()
    {
        $config = \OxidEsales\Eshop\Core\Registry::getConfig();

        $config->setConfigParam('iMaxMandates', $config->getConfigParam('IMS'));
        $config->setConfigParam('iMaxArticles', $config->getConfigParam('IMA'));
    }
175547
public static function Start()
  {
    global $_SERVER;
    if (!phoxy_conf()["is_ajax_request"] && phoxy_conf()["api_csrf_prevent"])
      die("Request aborted due API direct CSRF warning");

    if (phoxy_conf()["buffered_output"])
      ob_start();

    global $_GET;
    $get_param = phoxy::Config()["get_api_param"];
    $file = $_GET[$get_param];
    unset($_GET[$get_param]);

    if ($file === 'htaccess')
      exit('Rewrite engine work SUCCESS');

    try
    {
      include_once('rpc_string_parser.php');
      $parser = new \phoxy\rpc_string_parser();

      global $_phoxy_process_obj;
      $_phoxy_process_obj = $obj = $parser->GetRpcObject($file, $_GET);
      $a = $obj['obj'];

      $method = $obj['method'];
      if (is_string($method))
        $method = [$method, []];

      $result = $a->APICall($method[0], $method[1]);
    } catch (phoxy_protected_call_error $e)
    {
      $error = $e->result;

      if (!isset($error['error']))
        $error['phoxy_comment'] = "Phoxy caught soft error. Look inside network log";


      $result = new phoxy_return_worker($error);
    }

    $prepared = (string)$result;

    if (phoxy_conf()["buffered_output"])
    {
      $buffered_output = ob_get_contents();
      ob_end_clean();
    }

    if (phoxy_conf()["debug_api"] && !phoxy_conf()["is_ajax_request"])
    {
      echo "<h1>Result</h1>\n";
      var_dump($result->obj);
    }
    else
      header('Content-Type: application/json; charset=utf-8');

    if (!phoxy_conf()["debug_api"] || phoxy_conf()["is_ajax_request"])
      echo $prepared;
    else if (phoxy_conf()["buffered_output"])
      echo "\n<hr><h1>Log</h1>\n{$buffered_output}";
  }
63870
def build_and_start(query, directory):
    """"""

    Async(target=grep, args=[query, directory]).start()
1334071
function(page) {
      var t = this,
          newPages = t.pages.slice(0);
      newPages.push(page);
      t.tour.set('pages', newPages);
      t.tour.isDirty = true;
      t.setDirty(true);
      t.loadForm();
    }
1062308
public function start() {

        // indicate the library that it should execute queued requests
        $this->_queue = false;

        // if we have to pause between batches of requests, process them sequentially, in batches
        if ($this->pause_interval > 0) $this->_process_paused();

        // if we don't have to pause between batches of requests, process them all at once
        else $this->_process();

    }
209483
protected void loadPage(int pageNum) {

        int start = (pageNum - 1) * m_pageSize;
        List<CmsResultItemBean> results = m_resultBeans;
        int end = start + m_pageSize;
        if (end > results.size()) {
            end = results.size();
        }
        List<CmsResultItemBean> page = results.subList(start, end);
        boolean showPath = SortParams.path_asc.name().equals(m_searchBean.getSortOrder())
            || SortParams.path_desc.name().equals(m_searchBean.getSortOrder());
        m_resultsTab.addContentItems(page, true, showPath);
    }
786032
@Override
  public void start()
  {
    LOGGER.debug("Start Loading");
    // validate parameters
    validateParameters();

    if (_op == null)
    {
      this.abort(new ConnectionError("Loader started with no operation"));
      return;
    }

    initDateFormats();

    initQueues();

    if (_is_first_start_call)
    {
      // is this the first start call?

      try
      {
        if (_startTransaction)
        {
          LOGGER.debug("Begin Transaction");
          _processConn.createStatement().execute("begin transaction");
        }
        else
        {
          LOGGER.debug("No Transaction started");
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError("Failed to start Transaction",
                                         Utils.getCause(ex)));
      }

      if (_truncate)
      {
        truncateTargetTable();
      }

      try
      {
        if (_before != null)
        {
          LOGGER.debug("Running Execute Before SQL");
          _processConn.createStatement().execute(_before);
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError(
            String.format("Execute Before SQL failed to run: %s", _before),
            Utils.getCause(ex)));
      }
    }
  }
291897
def _save_results(self):
        """"""
        with open(self.results_file, 'w') as results_file:
            json.dump(self.results, results_file)
1095991
def starter(cls):
        """"""
        archive = cls.url + 'archive.html'
        data = getPageContent(archive, cls.session)
        search = compile(tagre("a", "href", r"(\d\d\d\d-\d\d.html)"))
        archivepages = search.findall(data)
        return cls.url + archivepages[-1]
452347
public void startSearch() {

        stopSearch();

        stop = false;

        MiscUtils.getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                isSearching = true;
                try {
                    if (finder != null) {
                        finder.start();
                    }

                    for (String aSrPath : srPath) {
                        getFile(new File(aSrPath));
                    }

                    if (!stop && finder != null) {
                        finder.finished();
                    }

                } finally {
                    isSearching = false;
                }

            }
        });
    }
868412
def process_resource(self, req, resp, resource):
        

        try:
            model = resource.model

            req.fields = fields.init(req, model)
            req.filters = filters.init(req, model)
            req.includes = includes.init(req, model)
            req.pages = pages.init(req, model)
            req.sorts = sorts.init(req, model)
        except AttributeError:
            pass
        except InvalidQueryParams as exc:
            abort(exc)
1060896
public function run()
    {
        $pagination = (new PageList())->getPagination();
        $app = Application::getFacadeApplication();
        $tracker = $app->make('statistics/tracker');

        do {
            if ($results = $pagination->getCurrentPageResults()) {
                /** @var \Concrete\Core\Page\Page $page */
                foreach ($results as $page) {
                    try {
                        $tracker->track($page);
                    } catch (\Exception $e) {
                        dd($e->getMessage(), $e->getTraceAsString());
                    }
                }
            }
        } while ($pagination->hasNextPage() && $pagination->setCurrentPage($pagination->getNextPage()));
    }
1127265
def StartFileFetch(self, pathspec, request_data=None):
    """"""
    # Create an index so we can find this pathspec later.
    self.state.indexed_pathspecs.append(pathspec)
    self.state.request_data_list.append(request_data)
    self._TryToStartNextPathspec()
653625
@PostConstruct
    private void initialize() {
        final MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();
        final String offset = multiParam(queryParams, "offset");
        final String page = multiParam(queryParams, "page", "pageNumber");
        final String size = multiParam(queryParams, "size", "pageSize", "limit");
        final String filter = multiParam(queryParams, "filter", "searchText");
        final String sort = multiParam(queryParams, "sort", "sortOrder");
        final OrderDirection orderDirection;
        String orderBy = multiParam(queryParams, "orderBy", "sortName");

        if (StringUtils.isBlank(orderBy) || !RegexSequence.Pattern.ALPHA_NUMERIC.matcher(orderBy).matches()) {
            orderBy = null;
        }

        if ("asc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.ASCENDING;
        } else if ("desc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.DESCENDING;
        } else {
            orderDirection = OrderDirection.UNSPECIFIED;
        }

        final Pagination pagination;
        if (StringUtils.isNotBlank(offset)) {
            pagination = new Pagination(Pagination.Strategy.OFFSET, offset, size);
        } else if (StringUtils.isNotBlank(page) && StringUtils.isNotBlank(size)) {
            pagination = new Pagination(Pagination.Strategy.PAGES, page, size);
        } else {
            pagination = new Pagination(Pagination.Strategy.OFFSET, 0, 100); // Always paginate queries from resources
        }
        this.alpineRequest = new AlpineRequest(getPrincipal(), pagination, filter, orderBy, orderDirection);
    }