FUNCTION: done( error, data )
Callback invoked upon completing a request.

@private
@param {Error|Null} error - error object
@param {String} data - response data
@returns {Void}
193384
function done( error, data ) {
		if ( error ) {
			return clbk( error );
		}
		data = transform( data );
		clbk( null, data );
	}
795275
function(data, done) {
      this._data.push(this._clone(data));
      var ret = this._data.length;
      done(null, ret);
    }
181762
function done(err) {

			that._gcw = 'done_get_creatures';

			bomb.defuse();

			// Unsee the 'getting_creatures' event
			that.unsee('getting_creatures');

			// Call next on the next tick (in case we call back with an error)
			Blast.nextTick(next);

			if (err) {
				that.log('error', 'Error getting creatures: ' + err)
				callback(err);
			} else {

				let result = [];

				for (let id in that.creatures_by_id) {
					if (that.creatures_by_id[id]) {
						result.push(that.creatures_by_id[id]);
					}
				}

				callback(null, result);
				that.emit('_got_creatures', err, result);
			}
		}
236883
function onResponse( error, data, info ) {
	if ( info ) {
		console.error( info );
	}
	if ( error ) {
		throw error;
	}
	console.log( data );
}
490054
function(error) {
		var that = this,
			param = this.chainParameter,
			stopPointer = {},
			utils = {
				stop: null,
				url: this.scraper.url,
				scraper: this,
				params: param,
				lastReturn: undefined
			},
			keep = true;
		this.chainParameter = null;

		if (error) {
			this.errorCallback(error, utils);
			this.doneCallback(utils);
			return;
		}

		async.eachSeries(this.promises, function dispatcher(fn, callback) {
			var done = function(err, lastReturn) {
				utils.lastReturn = lastReturn;
				if (err === stopPointer) {
					keep = false;
					callback(err);
				} else if (err) {
					callback(err);
				} else if (keep) {
					callback();
				}
			};
			utils.stop = function() {
				done(stopPointer, null);
			};

			try {
				fn.call(that, done, utils);
			} catch (err) {
				done(err, null);
			}
		}, function(err) {
			utils.stop = null;
			if (err && err !== stopPointer) {
				that.errorCallback(err, utils);
			}
			that.doneCallback(utils.lastReturn, utils);
			that.scraper.close();
		});
	}
1211515
function done( error ) {
		if ( error ) {
			return clbk( error );
		}
		count += 1;
		if ( count === len ) {
			clbk( null, concat( out ) );
		}
	}
328827
protected void error(E error) {
    this.error = checkNotNull(error);
    this.completed = true;
    for (Callback<T, E> callback : toBeNotified) {
      callback.error(error);
    }
  }
677733
function complete ( err, msg ){
      b9.off('hello', success ); // cleanup
      // optional callback, error-first...
      if ( typeof callback == 'function' ){
        callback( err, msg );
      }
    }
1067927
function(callback, err) {
    if (err) {
      if (callback) callback(err);
      return;
    }

    var duration = new Date().getTime() - this.start;
    this.logger.log('Done in ' + duration + 'ms.');

    if (callback) callback();
  }
136351
function get(done) {
    this.define();
    done(undefined, this.mixin({}, this.defaults, this.data, this.merge(
      this.data,
      this.queue.discharge(this.name)
    )));
  }
941098
function onComplete (err) {
    if (err) {
      console.log('interpolation encountered an error: ', err)
      return callback(err)
    }
    // set is complete and create a queue drain function
    // however, a feed may not have any interpolated times, so
    // `isComplete` is set in case nothing is pushed to the queue
    isComplete = true
    updateQueue.drain = () => {
      console.log('interpolation completed successfully')
      callback(err)
    }
  }
432789
function _jsonLoaded(callback, err, data) {
  if (err) return callback(err);
  var parsed;
  try {
    parsed = JSON.parse(data);
  } catch(jerr) {
    return callback(jerr);
  }
  callback(null, parsed);
}
1296698
function(url, done) {
  var receive = function(res) {
    if (res.statusCode != 200) {
      var msg = 'Failed to load ' + url + '\n' +
        'HTTP responce status code: ' + res.statusCode
      printError(msg)
      done(new Error(msg))
    } else {
      var content = ''
      res
        .on('end', function() {
          done(null, content)
        })
        .on('readable', function() {
          var chunk = res.read()
          content += chunk.toString()
        })
    }
  }

  try {
    require(url.indexOf('https') === 0 ? 'https' : 'http').get(url, receive).on('error', done)
  } catch (e) {
    done(e)
  }
}
43830
function done(status, response, headersString) {
            if (cache) {
                if (isSuccess(status)) {
                    cache.put(url, [status, response, parseHeaders(headersString)]);
                } else {
                    // remove promise from the cache
                    cache.remove(url);
                }
            }

            resolvePromise(response, status, headersString);
        }
644474
function(done) {
  return {
    success: function(res) {
      done(null, res);
    },
    error: function(res, err) {
      done(err);
    }
  };
}
162924
function(error) {
      this.errors.push(error);

      for (var i = 0, length = this.handlers.length; i < length; i++) {
        this.handlers[i](error);
      }
    }
1283725
function done( error, response, data ) {
		var info;
		if ( arguments.length === 1 ) {
			debug( 'No available rate limit information.' );
			return clbk( error );
		}
		debug( 'Request completed.' );

		// Get rate limit information:
		info = ratelimit( response.headers );
		debug( 'Rate limit: %d', info.limit );
		debug( 'Rate limit remaining: %d', info.remaining );
		debug( 'Rate limit reset: %s', (new Date( info.reset*1000 )).toISOString() );

		if ( error ) {
			return clbk( error, null, info );
		}
		clbk( null, data, info );
	}