called when all is done
427335
function gotTotal(err, total, models) {
            var last;
            var continuation;
            //generate or use a continuation token;
            if (models.length > 0 && opts.limit) {
                last = models[models.length - 1];

                if (typeof last.__verymeta.extra === 'object') {
                    if (last.__verymeta.extra.continuation) {
                        continuation = last.__verymeta.extra.continuation;
                    }
                }
            }
            opts.cb(err, models, {count: models.length, offset: offset, limit: limit, continuation: continuation, total: total});
        }
1075376
function()
			{
				if ( cssIsLoaded && jsIsLoaded )
				{
					// Mark the part as loaded.
					part._isLoaded = 1;

					// Call all pending callbacks.
					for ( var i = 0 ; i < pending.length ; i++ )
					{
						if ( pending[ i ] )
							pending[ i ]();
					}
				}
			}
466704
function done () {
    that.fetchQueue.stopFetching(key, arguments);
    that.store(key, arguments, callback);
  }
1375033
public function complete()
    {
        $this->stopped();

        $this->setStatus(Job::STATUS_COMPLETE);

        $this->redis->zadd(Queue::redisKey($this->queue, 'processed'), time(), $this->payload);
        Stats::incr('processed', 1);
        Stats::incr('processed', 1, Queue::redisKey($this->queue, 'stats'));

        Event::fire(Event::JOB_COMPLETE, $this);
    }
1088775
public void finish() {
        if ( finSignal == null && finished )
            return;
        // signal finish of execution, so remoting can clean up callback id mappings
        // override if always single result or finish can be emitted by the remote method
        // note one can send FINSILENT to avoid the final message to be visible to receiver callback/spore
        cb.complete(null, null);
        finished = true;
    }
160397
function done(context, template) {
      // Store the rendered template someplace so it can be re-assignable.
      var rendered;

      // Trigger this once the render method has completed.
      manager.callback = function(rendered) {
        // Clean up asynchronous manager properties.
        delete manager.isAsync;
        delete manager.callback;

        root._applyTemplate(rendered, manager, def);
      };

      // Ensure the cache is up-to-date.
      LayoutManager.cache(url, template);

      // Render the View into the el property.
      if (template) {
        rendered = root.renderTemplate.call(root, template, context);
      }

      // If the function was synchronous, continue execution.
      if (!manager.isAsync) {
        root._applyTemplate(rendered, manager, def);
      }
    }
194135
def _trigger(self):
        
        self._completed.set()
        for callback in self._callbacks:
            callback(self)
1131217
public void finished()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "finished");
      
    if(msgStoreNonLockingCursor!=null)
    {
      msgStoreNonLockingCursor.finished();
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "finished");
  }
339000
def finish(self):
        ''

        self.finished = True
        self.update(self.maxval)
        self.fd.write('\n')
        if self.signal_set:
            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
520545
function completed( event ) {
	        // readyState === "complete" is good enough for us to call the dom ready in oldIE
	        if ( w3c || event.type === LOAD || doc[READYSTATE] === COMPLETE ) {
	            detach();
	            ready();
	        }
	    }
793425
function one() {
  var self = this

  self.actual++

  if (self.actual >= self.expected) {
    self.emit('done')
  }
}
753399
def after(self, context):
        ""
        self._invoke(self._after, context)
        run.after_each.execute(context)
112595
function _finish() {
    done++;
    if ( count === 0 || done === count ) {
      rtn.sort(Trip.sortByDepartureTime);
      return callback(null, rtn);
    }
  }
921330
function done( error, results ) {
		if ( error ) {
			return clbk( error );
		}
		if ( results ) {
			return clbk( null, results );
		}
		clbk();
	}
818710
public function done()
	{
		// Compute the totall length of the output
		$length = $this->contentLength + $this->initMessageLength;

		// Back up all the way
		$this->backspace($length, true);

		// In case this gets used again...
		$this->contentLength     = 0;
		$this->initMessageLength = 0;
	}
487885
def flush(self):
        

        done = threading.Event()

        def _callback():
            done.set()

        self.defer(_callback)
        done.wait()
149851
function done( error, results, info ) {
			error = error || null;
			results = results || null;
			info = info || null;
			clbk( error, results, info );
		}