Finish point

return void
764515
public function finish()
    {
        $this->setActive(false);
        $this->setStopTimeIfNotExists();
        $this->setStopMemoryUsage();
        $this->setMemoryPeak();
        $this->setDifferenceTime();
        $this->setDifferenceMemory();
    }
910665
private function finish()
    {
        if ($this->main_database !== null) {
            $this->main_database->disconnect();
        }

        $this->microtime_end = microtime(true);
        $this->microtime_elapsed = $this->microtime_end - $this->microtime_start;
        $this->traceLog("Execution time", sprintf("%.3f ms", $this->microtime_elapsed * 1000));
    }
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();
    }
1018291
public void finish() {
		if (startMeasure == null) {
			Say.info("No invokations are measured");
		}
		else {
			long total = System.currentTimeMillis() - startMeasure;
			double average = 1d * total / counter;
			logFinished(total, average);
		}
	}
724121
public void finish() {
        for (Map.Entry<String, String> entry : posTags.entrySet()) {
            posWriter.println(entry.getKey() + " " + entry.getValue());
        }
        posWriter.flush();
        posWriter.close();

        writer.flush();
        writer.close();
    }
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
203185
public void finish() {
        if (mAccountAuthenticatorResponse != null) {
            // send the result bundle back if set, otherwise send an error.
            if (mResultBundle != null) {
                mAccountAuthenticatorResponse.onResult(mResultBundle);
            } else {
                mAccountAuthenticatorResponse.onError(AccountManager.ERROR_CODE_CANCELED,
                        "canceled");
            }
            mAccountAuthenticatorResponse = null;
        }
        super.finish();
    }
1018887
function end () {
      sent = true;
      // next tick it to avoid express catching runtime error in the callback
      //   getting caught by express and triggering app's error handler
      process.nextTick(function () {
        res.emit('finish');
        cb(null, res);
      });
    }
675680
public static function finish() {

        if(empty(self::$profiler) === false) {

            self::$profiler = array_merge([
                'elapsed'   =>  self::getTime(time() - self::$profiler['start']),
                'memory'    =>  self::getMemoryUsage(),
                'cpu'       =>  self::getUsageCPU(),
                'stack'     =>  self::getStackCalls()
            ], self::$profiler);

            unset(self::$profiler['start']);
        }
    }
1237958
public synchronized void finished()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "finished");
    
    checkEntryParent();
    
    synchronized(parentList)
    {
      //remove the cursor from the list
      //this will set the parent list reference to null and make the
      //cursor seubsequently unusable
      forceRemove();      
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "finished");        
  }
702569
def finish (self):
        """"""
        if not self.urlqueue.empty():
            # This happens when all checker threads died.
            self.cancel()
        for t in self.threads:
            t.stop()
1293911
@Override
    public void finish() {
        // An assertion failure here means this CE
        // did not come from a CE pool and this
        // should never be the case;
        //assert cacheEntryPool != null;
        // if cacheEntryPool is null, the cacheEntry is not allocated from the pool
        if (cacheEntryPool != null) {
            synchronized (cacheEntryPool.cache) {
                decRefCount();
                if (refCount.get() <= 0) {
                    if (refCount.get() < 0)
                        refCount.set(0);
                    if (removeWhenUnpinned && refCount.get() == 0) {
                        returnToPool();
                    }
                }
            }
        } else {
            synchronized (this.id) {
                decRefCount();
                if (refCount.get() <= 0) {
                    reset();
                }
            }
        }
    }
582167
public function end()
    {
        if (!$this->_seekable) {
            throw new RuntimeException("Cannot seek on non seekable stream.");
        }
        if (!count($this->_streams)) {
            throw new RuntimeException('The stream container is empty no seek operation is possible.');
        }
        $this->_current = count($this->_streams) - 1;
        $stream = $this->_streams[$this->_current];
        $stream->seek(0, SEEK_END);
    }
961081
public final void finished()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "finished");

        synchronized(_subCursors)
        {
            for (int priority = Priorities.LOWEST_PRIORITY; priority <= Priorities.HIGHEST_PRIORITY; priority++)
            {
                if (null != _subCursors[priority])
                {
                    _subCursors[priority].finished();
                    _subCursors[priority] = null;
                }
            }
        }
        _owningList._removeCursor(this);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "finished");
    }
1088647
@Override
    public void finish() {
        if (started.get() && !finished.getAndSet(true)) {
            waitUntilFinished();
            super.finish();
            // recreate thread (don't start) for processor reuse
            createProcessorThread();
            clearQueues();
            started.set(false);
        }
    }
4686
private void finishValue()
    {
        final ContainerInfo current = currentContainer();
        if (current != null && current.type == ContainerType.ANNOTATION)
        {
            // close out and patch the length
            popContainer();
        }
        hasWrittenValuesSinceFinished = true;
        hasWrittenValuesSinceConstructed = true;
    }
558374
public static void endDoing() {
    long elapsed = System.currentTimeMillis() - startTime;
    System.err.println("done [" + nf.format(((double) elapsed) / 1000) + 
                       " sec].");
  }