Atomically marks the breakpoint as completed.

    Returns:
      True if the breakpoint wasn't marked already completed or False if the
      breakpoint was already completed.
333013
def _SetCompleted(self):
    
    with self._lock:
      if self._completed:
        return False
      self._completed = True
      return True
1226047
def set_done(self):
        
        self.__record_progress(Status.DONE)

        # Delete restoration point for last step to indicate process has been completed
        os.remove(self.get_restore_path(Status.LAST))
1166405
public synchronized void complete() {
        if( logger.isInfoEnabled() ) {
            logger.info("[" + this + "] Marking complete");
        }
        if( loaded ) {
            return;
        }
        loaded = true;
        lastTouch = System.currentTimeMillis();
        if( waiting != null && waiting.isEmpty() ) {
            waiting = null;
        }
        notifyAll();
    }
318953
def clear_breakpoint(self, breakpoint_number):
        
        if not (0 <= breakpoint_number < len(IKBreakpoint.breakpoints_by_number)):
            return "Found no breakpoint numbered %s" % breakpoint_number
        bp = IKBreakpoint.breakpoints_by_number[breakpoint_number]
        if not bp:
            return "Found no breakpoint numbered: %s" % breakpoint_number
        _logger.b_debug("    clear_breakpoint(breakpoint_number=%s) found: %s",
                        breakpoint_number,
                        bp)
        bp.clear()
        if self.pending_stop or IKBreakpoint.any_active_breakpoint:
            self.enable_tracing()
        else:
            self.disable_tracing()
        return None
683821
def _finish(self):
        
        if self.active and self.cnt >= self.max_iter:
            self.total_time = self._elapsed()
            self.end = time.time()
            self.last_progress -= 1  # to force a refreshed _print()
            self._print()
            if self.track:
                self._stream_out('\nTotal time elapsed: ' +
                                 self._get_time(self.total_time))
            self._stream_out('\n')
            self.active = False
1241314
void mark()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "mark");
      SibTr.exit(tc, "mark");
    }

    _marked = true;
  }
1199356
public function markComplete() {
		$this->Status = "Complete";
		$this->log("Pipeline completed successfully.");
		$this->write();
		// Some steps may pre-emptively send a success message before the pipeline itself has completed
		if($this->LastMessageSent !== self::ALERT_SUCCESS) {
			$this->sendMessage(self::ALERT_SUCCESS);
		}
	}
484145
def CheckBreakpointsExpiration(self):
    """"""
    with self._lock:
      current_time = BreakpointsManager.GetCurrentTime()
      if self._next_expiration > current_time:
        return

      expired_breakpoints = []
      self._next_expiration = datetime.max
      for breakpoint in six.itervalues(self._active):
        expiration_time = breakpoint.GetExpirationTime()
        if expiration_time <= current_time:
          expired_breakpoints.append(breakpoint)
        else:
          self._next_expiration = min(self._next_expiration, expiration_time)

    for breakpoint in expired_breakpoints:
      breakpoint.ExpireBreakpoint()
1187509
def clear
      Debugger.breakpoints.clear if Debugger.started?
      Pry.processor.debugging = false
    end
286388
def isFinished(self):
        
        finished = (self.env._step == len(self.env.profile))
        if finished:
            logger.info("Finished episode.")
        return finished
725532
def Clear(self):
    
    self._RemoveImportHook()
    if self._cookie is not None:
      native.LogInfo('Clearing breakpoint %s' % self.GetBreakpointId())
      native.ClearConditionalBreakpoint(self._cookie)
      self._cookie = None

    self._completed = True
1018867
def _check_view_change_completed(self):
        
        logger.info('{} running the scheduled check for view change completion'.format(self))
        if not self.view_changer.view_change_in_progress:
            logger.info('{} already completion view change'.format(self))
            return False

        self.view_changer.on_view_change_not_completed_in_time()
        return True
180115
def breakpoint(self, name):
        
        if name not in self._breakpoints:
            self.warning("Reached breakpoint %s but found no "
                         "callback registered")
            return
        cb = self._breakpoints[name]
        cb.callback(None)
        return cb
116225
def clear(self):
        
        del IKBreakpoint.breakpoints_by_file_and_line[self.file_name, self.line_number]
        IKBreakpoint.breakpoints_by_number[self.number] = None
        IKBreakpoint.breakpoints_files[self.file_name].remove(self.line_number)
        if len(IKBreakpoint.breakpoints_files[self.file_name]) == 0:
            del IKBreakpoint.breakpoints_files[self.file_name]
        IKBreakpoint.update_active_breakpoint_flag()
664922
def is_complete(self):
        
        return all(
            [node.route_allocation() is not None for node in list(self._nodes.values()) if node != self._problem.depot()]
        )
221636
boolean isMarked()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "isMarked");
      SibTr.exit(tc, "isMarked", new Boolean(_marked));
    }

    return _marked;
  }
813721
def breakpoints( self ):
        
        lines = []
        result = self.markerFindNext(0, self._breakpointMarker + 1)
        while ( result != -1 ):
            lines.append(result)
            result = self.markerFindNext(result + 1, self._breakpointMarker + 1)
        return lines