Emit everything from the collector.
972826
protected boolean combine(Object[] srcs, TupleWritable dst) {
    assert srcs.length == dst.size();
    return true;
  }
108991
@Deprecated
    public static Collection collectAll(Collection self, Collection collector, Closure transform) {
        return collectNested((Iterable)self, collector, transform);
    }
285667
def _emit(self, **kwargs):
        '''
        
        '''
        oc_dict = {}
        for mapping, result_key in kwargs['mapping']['variables'].items():
            result = kwargs[result_key]
            oc_dict = napalm_logs.utils.setval(mapping.format(**kwargs), result, oc_dict)
        for mapping, result in kwargs['mapping']['static'].items():
            oc_dict = napalm_logs.utils.setval(mapping.format(**kwargs), result, oc_dict)

        return oc_dict
214207
def emit(self, event, data=None, room=None, include_self=True,
             namespace=None, callback=None):
        """"""
        return self.socketio.emit(event, data, room=room,
                                  include_self=include_self,
                                  namespace=namespace or self.namespace,
                                  callback=callback)
684438
def _emit_via(parent, options = {}, &block)
      _emit(options.merge(:parent  => parent,
                            :output  => parent.output,
                            :helpers => parent.helpers), &block)
    end
532049
function executeAll (cfg) {
    console.log(`${clr.DIM+clr.LIGHT_MAGENTA}Package: ${cfg.packageRoot}${clr.RESET}`);
    return new Promise((resolve, reject) => {
        createObservable(cfg).subscribe({
            next ({command, exitCode}) {
                if (exitCode == 0)
                    cfg.log(`${EMIT_COLOR}just-build ${cfg.tasksToRun.join(' ')}`+
                            ` done.${clr.RESET}${cfg.watchMode ? NOW_WATCHING_COLOR+' Still watching...'+clr.RESET : ''}`);
                else 
                    cfg.log(`just-build ${cfg.tasksToRun.join(' ')} failed. ${command} returned ${exitCode}`);
            },
            error (err) {
                reject(err);
            },
            complete () {
                resolve();
            }                
        });
    });
}
214121
def notify_all(self):
        """"""
        self.condition.acquire()
        # python 3.x
        try:
            self.condition.notify_all()
        except:
            self.condition.notifyAll()
        self.condition.release()
433478
def emit(self, dictValues, key, value):
        
        if key and value:
            dictValues[key] = value
248153
def observe_all(self, callback: Callable[[str, Any, Any], None]):
        """"""
        self._all_callbacks.append(callback)
879226
function() {
  var that = this;
  var boundEmitComplete = emitComplete.bind(this);
  
  EventEmitter.call(this);

  this.middleware = [];
  this.server = net.createServer(function(conn) {
    var buffer = '';
    var info = null;

    conn.on('data', function(data) {
      buffer += data;

      if(!info) {
        if(buffer.indexOf('\f') !== -1) {
          var split = buffer.split('\f');
          
          try {
            info = JSON.parse(split[0]);
            buffer = split[1];
          } catch(e) {
            that.emit('error', e);
          }
        }
      }

      if(buffer && info) {
        handleEntries(buffer, info, that.middleware, boundEmitComplete);
        buffer = '';
      }
    });

    conn.on('end', function() {
      that.emit('end');
    });

    conn.on('error', function(err) {
      that.emit('error', err);
    });
  });
}
590967
public void emit() {
		requestLogger.setAndDisplay(frontier.fetchedResources.get() + frontier.fetchedRobots.get());
		final long duplicates = frontier.duplicates.get();
		final long archetypes = frontier.archetypes();
		resourceLogger.setAndDisplay(archetypes + duplicates);
		transferredBytesLogger.setAndDisplay(frontier.transferredBytes.get());
		receivedURLsLogger.setAndDisplay(frontier.numberOfReceivedURLs.get());

		LOGGER.info("Duplicates: " + Util.format(duplicates) + " (" + Util.format(100.0 * duplicates / (duplicates + archetypes)) + "%)");
		LOGGER.info("Archetypes 1XX/2XX/3XX/4XX/5XX/Other: "
				+ Util.format(frontier.archetypesStatus[1].get()) + "/"
				+ Util.format(frontier.archetypesStatus[2].get()) + "/"
				+ Util.format(frontier.archetypesStatus[3].get()) + "/"
				+ Util.format(frontier.archetypesStatus[4].get()) + "/"
				+ Util.format(frontier.archetypesStatus[5].get()) + "/"
				+ Util.format(frontier.archetypesStatus[0].get()));

		LOGGER.info("Outdegree stats: " + frontier.outdegree.toString());
		LOGGER.info("External outdegree stats: " + frontier.externalOutdegree.toString());
		LOGGER.info("Archetype content-length stats: " + frontier.contentLength.toString());
		LOGGER.info("Archetypes text/image/application/other: "
				+ Util.format(frontier.contentTypeText.get()) + "/"
				+ Util.format(frontier.contentTypeImage.get()) + "/"
				+ Util.format(frontier.contentTypeApplication.get()) + "/"
				+ Util.format(frontier.contentTypeOthers.get()));

		LOGGER.info("Ready URLs: " + Util.format(frontier.readyURLs.size64()));

		LOGGER.info("FetchingThread waits: " + frontier.fetchingThreadWaits.get() + "; total wait time: " + frontier.fetchingThreadWaitingTimeSum.get());
		frontier.resetFetchingThreadsWaitingStats();
	}
195962
def create_and_run_collector(document, options):
        """"""
        collector = None
        if not options.report == 'off':
            collector = Collector()
            collector.store.configure(document)
            Event.configure(collector_queue=collector.queue)
            collector.start()
        return collector
302968
public void emitAnnotations(@Nonnull ZipkinAnnotationsStore zipkinAnnotationsStore) {
        Objects.requireNonNull(zipkinAnnotationsStore);
        zipkinSpanCollector.collect(zipkinAnnotationsStore.generate());
    }
905884
def emitMany(*args, **kwargs):
    """"""
    global MODE
    if MODE == Bolt:
        emitManyBolt(*args, **kwargs)
    elif MODE == Spout:
        emitManySpout(*args, **kwargs)
733523
def emit(self, arg=None):
        """"""
        for model,name in self.__get_models__():
            model.notify_signal_emit(name, arg)
1333772
function emitLine(line, isEnd) {
  if (this.filters.every(function(fn) { return fn(line) }))
    emit.call(this, 'data', line, !!isEnd);
}
631674
def apply(self, collection, data):
        """"""
        value = self.value(data)
        if value is self.default:
            return collection
        return [o for o in collection if getattr(o, self.name, None) == value]