Select the next cluster.
974752
def next(self):
        """"""
        if not self.selected:
            self.cluster_view.next()
        else:
            self.similarity_view.next()
920384
def next(self):
        """"""
        try:
            self._current = self.services.pop(0)
        except IndexError:
            raise StopIteration
        else:
            return self._current
1051824
@Override
  public ORecordIteratorClusters<REC> last() {
    currentClusterIdx = clusterIds.length - 1;
    current.clusterPosition = liveUpdated ? database.countClusterElements(clusterIds[currentClusterIdx]) : lastClusterPosition + 1;
    return this;
  }
877561
def next(self):
        
        while True:
            self.cur_idx += 1
            if self.__datasource.populate_iteration(self):
                return self

        raise StopIteration
395470
public function next()
    {
        $this->index++;

        // Prefetch the next element
        if ($this->validOnNext) $this->prefetch();

        if ($this->uses_groups) {
            // Notify the grouping helper of the change
            $this->groups->reset();
        }
    }
107901
public void waitToStartCluster(final String clusterName, int nodesCount, int timeout)
    {
        log.debug(String.format(
                "Waiting  up to %ds for the Elasticsearch cluster to start ...",
                timeout));
        Awaitility.await()
                .atMost(timeout, TimeUnit.SECONDS)
                .pollDelay(1, TimeUnit.SECONDS)
                .pollInterval(1,  TimeUnit.SECONDS)
                .until(new Callable<Boolean>()
                        {
                            @Override
                            public Boolean call() throws Exception
                            {
                                return isClusterRunning(clusterName, nodesCount, client);
                            }
                        }
                );
        log.info("The Elasticsearch cluster has started");
    }
1175815
public long getNextCluster(long cluster) {
        testCluster(cluster);
        long entry = entries[(int) cluster];
        if (isEofCluster(entry)) {
            return -1;
        } else {
            return entry;
        }
    }
836271
def next(self):
        """"""
        d = None
        if self._first_results:
            d = succeed(EsUtils.extract_hits(self._first_results))
            self._first_results = None
        elif self._scroll_id:
            d = self._scroll_next_results()
        else:
            raise StopIteration()
        return d
874082
def cluster_forget(self, node_id):
        """"""
        fut = self.execute(b'CLUSTER', b'FORGET', node_id)
        return wait_ok(fut)
174551
def go_next_thumbnail(self):
        """"""
        if self.current_thumbnail is not None:
            index = self._thumbnails.index(self.current_thumbnail) + 1
            index = 0 if index >= len(self._thumbnails) else index
            self.set_current_index(index)
            self.scroll_to_item(index)
329257
def iter_next(self):
        """"""
        self.cursor += self.batch_size
        return self.cursor < self.num_data
1187801
protected void updateClusters() {
		for( int i = 0; i < clusters.size; i++ ) {
			clusters.data[i].reset();
		}

		int indexPixel = 0;
		for( int y = 0; y < input.height&& !stopRequested; y++ ) {
			int indexInput = input.startIndex + y*input.stride;
			for( int x =0; x < input.width; x++ , indexPixel++ , indexInput++) {
				Pixel p = pixels.get(indexPixel);

				// convert the distance each cluster is from the pixel into weights
				p.computeWeights();

				for( int i = 0; i < p.clusters.size; i++ ) {
					ClusterDistance d = p.clusters.data[i];
					d.cluster.x += x*d.distance;
					d.cluster.y += y*d.distance;
					d.cluster.totalWeight += d.distance;
					addColor(d.cluster.color,indexInput,d.distance);
				}
			}
		}

		// recompute the center of each cluster
		for( int i = 0; i < clusters.size; i++ ) {
			clusters.data[i].update();
		}
	}
808983
def _advance_cluster_time(self, cluster_time):
        """"""
        if self._cluster_time is None:
            self._cluster_time = cluster_time
        elif cluster_time is not None:
            if cluster_time["clusterTime"] > self._cluster_time["clusterTime"]:
                self._cluster_time = cluster_time
1239663
private void quickSelect(List<P> points, int splitAxis, int medianNum) {
		int numPoints = points.size();

		if( tmp.length < numPoints ) {
			tmp = new double[numPoints];
			indexes = new int[ numPoints ];
		}
		for( int i = 0; i < numPoints; i++ ) {
			tmp[i] = distance.valueAt(points.get(i),splitAxis);
		}

		QuickSelect.selectIndex(tmp, medianNum, numPoints, indexes);
	}
165858
def _put_cluster(self, dic, params=None):
    """"""
    cluster = self._put('', ApiCluster, data=dic, params=params)
    self._update(cluster)
    return self
1165550
def get_cluster_assignment(self):
        """"""
        plan = self.get_cluster_plan()
        assignment = {}
        for elem in plan['partitions']:
            assignment[
                (elem['topic'], elem['partition'])
            ] = elem['replicas']

        return assignment
776376
def focus_next(self):
        """"""
        w, focuspos = self.get_focus()
        next = self._tree.next_position(focuspos)
        if next is not None:
            self.set_focus(next)