Retrieves the next set of results from the service.
168252
def _nextPage(self, offset):
        """"""
        self.logger.debug("Iterator crecord=%s" % str(self.crecord))

        params = {
            'q': self.q,
            'rows': '0',
            'facet': 'true',
            'facet.field': self.field,
            'facet.limit': str(self.pagesize),
            'facet.offset': str(offset),
            'facet.zeros': 'false',
            'wt': 'python',
        }
        if self.fq is not None:
            params['fq'] = self.fq
        request = urllib.parse.urlencode(params, doseq=True)
        rsp = self.client.doPost(
            self.client.solrBase + '', request, self.client.formheaders
        )
        data = eval(rsp.read())
        try:
            self.res = data['facet_counts']['facet_fields'][self.field]
            self.logger.debug(self.res)
        except Exception:
            self.res = []
        self.index = 0
669273
public List<T> results() throws InterruptedException {
        while (true) {
            synchronized (this) {
                if (completed) {
                    return results == null ? Collections.emptyList()
                        : Collections.unmodifiableList(results);
                }
                wait();
            }
        }
    }
87430
@Override
    public DataSet next() {
        DataSet next = iter.next();
        next.setLabels(next.getFeatures());
        return next;
    }
410276
def next(self):
        
        if self._has_finished:
            raise StopIteration

        if not len(self._buffer):
                    
            results = self.fetch_next_block()
            self._buffer.extend(results)
            
        if not len(self._buffer):
            raise StopIteration
            
        return self._buffer.popleft()
607013
def fetch_next_page(self):
        
        if self.response_future.has_more_pages:
            self.response_future.start_fetching_next_page()
            result = self.response_future.result()
            self._current_rows = result._current_rows  # ResultSet has already _set_current_rows to the appropriate form
        else:
            self._current_rows = []
229091
def get_all():
    '''
    
    '''
    services = _get_services()

    ret = set()
    for service in services:
        ret.add(service['ServiceName'])

    return sorted(ret)
966072
def get_items(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.ItemList(self._results, runtime=self._runtime)
891875
function Next($rs)
	{
		$this->RequireConnection();
		
		$this->handler->Log(DBH_LOG_DEBUG, "Fetching next result as array");
		return $this->adapter->Fetch($rs);

	}
727191
public boolean next()
    {
        if (this.iter == null) {
            this.iter = new ArrayList<>(this.values).iterator();
        }
        final boolean ret = this.iter.hasNext();
        if (ret) {
            this.current = this.iter.next();
        }
        return ret;
    }
1041647
def next(self):
    """"""
    if self._fut is None:
      self._fut = self._iter.getq()
    try:
      try:
        # The future result is set by this class's _extended_callback
        # method.
        # pylint: disable=unpacking-non-sequence
        (ent,
         self._cursor_before,
         self._cursor_after,
         self._more_results) = self._fut.get_result()
        return ent
      except EOFError:
        self._exhausted = True
        raise StopIteration
    finally:
      self._fut = None
870283
def get_records(self):
        
        # Won't be able to find new records.
        if self.exhausted:
            return []

        # Already caught up, just the one call please.
        if self.empty_responses >= CALLS_TO_REACH_HEAD:
            return self._apply_get_records_response(self.session.get_stream_records(self.iterator_id))

        # Up to 5 calls to try and find a result
        while self.empty_responses < CALLS_TO_REACH_HEAD and not self.exhausted:
            records = self._apply_get_records_response(self.session.get_stream_records(self.iterator_id))
            if records:
                return records

        return []
1071206
List<Result> getResult() {
    return ImmutableList.copyOf(Iterables.filter(results.values(), USED_RESULTS));
  }
978515
@Override
  public void next() {
    if (!hasNext()) {
      throw new IllegalDataException("No more data");
    }
    for (final ITimeSyncedIterator sub : queries.values()) {
      sub.next(timestamp);
    }
    timestamp = nextTimestamp();
  }
1125304
function next() {
		if ( count === len ) {
			debug( 'Finished all queries.' );
			out.meta.success = scount;
			out.meta.failure = fcount;
			return clbk( null, out );
		}
		if ( idx < len ) {
			debug( 'Querying for package: `%s` (%d)...', pkgs[idx], idx );
			request( pkgs[idx], opts, onResponse( pkgs[idx], idx ) );
			idx += 1;
		}
	}
190865
def get_services(self):
        """"""
        self.request(EP_GET_SERVICES)
        return {} if self.last_response is None else self.last_response.get('payload').get('services')
1154624
def next(self):
        
        if self.rows is None:
            raise ProgrammingError(
                "No result available. " +
                "execute() or executemany() must be called first."
            )
        elif not self._closed:
            return next(self.rows)
        else:
            raise ProgrammingError("Cursor closed")
387590
final public function next()
    {
        ++$this->position;

        if ($this->position < $this->limit) {
            return;
        }

        $this->offset += $this->limit;
        $this->filters['offset'] = $this->offset;
        $this->filters['limit'] = $this->limit === 0 ? 20 : $this->limit;
        $dataWrapper = $this->client->search($this->resource, $this->filters);

        //Limit should be the total number returned, not the specified limit in the query params
        $this->limit = $dataWrapper->getData()->getCount();
        $this->total = $dataWrapper->getData()->getTotal();
        $this->results = $dataWrapper->getData()->getResults();
        $this->position = 0;
    }