Check all Questions for completeness

        For now, completeness simply means that all questions have been
        responded to and not skipped or cleared.
971212
def is_complete(self):
        
        self._update_questions()  # Make sure questions list is current
        for question_map in self._my_map['questions']:
            if 'missingResponse' in question_map['responses'][0]:
                return False
        return True
852677
public boolean isEmpty() {
        boolean empty = true;
        boolean done = false;
        while (empty && !done) {
            for (ConcurrentServiceReferenceSet<V> s : elementMap.values()) {
                empty &= s.isEmpty();
            }
            done = true;
        }
        return empty;
    }
1253970
def is_finished(self):
        
        self.get_info()

        if 'status' not in self.info:
            return False
        if 'isFinished' not in self.info['status']:
            return False

        return self.info['status']['isFinished']
436618
private ScanStatus resplitPartiallyCompleteTasks(ScanStatus status) {
        boolean anyUpdated = false;
        int nextTaskId = -1;

        for (ScanRangeStatus complete : status.getCompleteScanRanges()) {
            if (complete.getResplitRange().isPresent()) {
                // This task only partially completed; there are still more data to scan.
                if (nextTaskId == -1) {
                    nextTaskId = getNextTaskId(status);
                }

                ScanRange resplitRange = complete.getResplitRange().get();

                // Resplit the un-scanned portion into new ranges
                List<ScanRange> subRanges = resplit(complete.getPlacement(), resplitRange, status.getOptions().getRangeScanSplitSize());
                // Create new tasks for each subrange that are immediately available for being queued.
                List<ScanRangeStatus> resplitStatuses = Lists.newArrayListWithCapacity(subRanges.size());
                for (ScanRange subRange : subRanges) {
                    resplitStatuses.add(
                            new ScanRangeStatus(nextTaskId++, complete.getPlacement(), subRange,
                                    complete.getBatchId(), complete.getBlockedByBatchId(), complete.getConcurrencyId()));
                }

                _scanStatusDAO.resplitScanRangeTask(status.getScanId(), complete.getTaskId(), resplitStatuses);

                anyUpdated = true;
            }
        }

        if (!anyUpdated) {
            return status;
        }

        // Slightly inefficient to reload but less risky than trying to keep the DAO and in-memory object in sync
        return _scanStatusDAO.getScanStatus(status.getScanId());
    }
229485
def is_finished(self):
        """"""

        if self._total_time > self._global_time_limit:
            logger.warning("Exceeded global time limit {} / {}".format(
                self._total_time, self._global_time_limit))
            return True

        trials_done = all(trial.is_finished() for trial in self._trials)
        return trials_done and self._search_alg.is_finished()
1028401
def is_complete(self, zmax=118):
        
        for z in range(1, zmax):
            if not self[z]: return False
        return True
1187558
@Override
    public boolean hasNext() {
        nextAnswer = findNextAnswer();
        if (nextAnswer != null) return true;

        //iter finished
        if (reiterationRequired) {
            long dAns = answers.size() - oldAns;
            if (dAns != 0 || iter == 0) {
                LOG.debug("iter: {} answers: {} dAns = {}", iter, answers.size(), dAns);
                iter++;
                states.push(query.subGoal(new ConceptMap(), new UnifierImpl(), null, new HashSet<>()));
                oldAns = answers.size();
                return hasNext();
            }
        }

        toComplete.forEach(query.tx().queryCache()::ackCompleteness);

        return false;
    }
946014
def number_of_completed_responses
      if statistics && !statistics.empty? && (completed_data = statistics.find { |a| a[0] == 'Complete' })
        completed_data[1]
      else
        0
      end
    end
122781
public boolean completed() {
		if (engine == null) {
			return false;
		}

		if (length.isEnabled()) {
			if (timeout > 0) {
				return false;
			}
			return completed;
		}
		if (emitCount.isEnabled()) {
			if (leftToEmit > 0) {
				return false;
			}
			return completed;
		}

		if (wrapUp) {
			return completed;
		}
		
		return false;
	}
857515
def complete(self):
        """"""
        if None not in [v for v in self.squares]:
            return True
        if self.winner() is not None:
            return True
        return False
233161
def completions(self):
        
        debug.speed('completions start')
        comps = self._evaluator.complete()
        debug.speed('completions end')

        return sorted(comps, key=lambda x: (x.name.lower()))
78904
public synchronized boolean complete(Response result) {
        if (completed) {
            return false;
        }
        completed = true;
        this.result = result;
        notifyAll();
        return true;
    }
150773
public static boolean isCompletedSuccessfully(CompletionStage<?> stage) {
      CompletableFuture<?> future = stage.toCompletableFuture();
      return future.isDone() && !future.isCompletedExceptionally();
   }
98634
@Override
  public boolean complete()
  {
    OutputStream os = _os;
    _os = null;
    
    IoUtil.close(os);

    return true;
  }
83481
def complete(self):
        """"""
        if Part.count(self) != self.last_part_number + 1:
            raise MultipartMissingParts()

        with db.session.begin_nested():
            self.completed = True
            self.file.readable = True
            self.file.writable = False
        return self
957307
public void complete() {
        this.endDate = new Date();
        
        if (reports.stream().allMatch(report -> report.isSuccessful() == true)) {
            this.successful = true;
        }
    }
396588
void complete()
    {
        _file=_stack[_top].getFileName()+":"+_stack[_top].getLineNumber();
        _method=_stack[_top].getClassName()+"."+_stack[_top].getMethodName();
        _depth=_stack.length-_top;
        _thread = Thread.currentThread().getName();
    }