Set alternate response emitter to use.

@param string $emitter
@param string $streamEmitter
776147
public function emitter(string $emitter, string $streamEmitter = null): void
    {
        $server = $this->server ?? $this->getServer();
        $server->setEmitter($emitter);

        $streamEmitter && $this->get('response')->setEmitter($streamEmitter);
    }
698953
public void setEmissive(float emissive[]){
        for(int i = 0; i<emissive.length;i++)
            this.emissive[i]=emissive[i];
        Em = true;
    }
1079000
protected function emitOnChange($method = false)
    {
        if (!$this->onChangeAlreadyEmittedBy) {
            $this->emit('change', [$this]);
            $this->onChangeAlreadyEmittedBy = $method;
        }
    }
1273203
function init(noEmitter) {
	if (!noEmitter) {
		if (emitter) apperror.removeErrorListener(emitter)
		emitter = new events.EventEmitter
		emitter.id = 'Api Manager'
		apperror.addErrorListener(emitter)
	}
	return emitter
}
1126757
function toEmitter( selection, target ){
    
    // Apply the entire Emitter API
    if( selection === API ){
        asEmitter.call( target );
    
    // Apply only the selected API methods
    } else {
        let index, key, mapping, names, value;
        
        if( typeof selection === 'string' ){
            names = selection.split( ' ' );
            mapping = API;
        } else {
            names = Object.keys( selection );
            mapping = selection;
        }
        
        index = names.length;
        
        while( index-- ){
            key = names[ index ];
            value = mapping[ key ];
            
            target[ key ] = typeof value === 'function' ?
                value :
                API[ value ];
        }
    }
}
49141
function MessageEmitter(ptcl, opts) {
  opts = opts || {};
  events.EventEmitter.call(this);

  this._ptcl = ptcl;
  this._strict = !!opts.strictErrors;
  this._endWritable = !!utils.getOption(opts, 'endWritable', true);
  this._timeout = utils.getOption(opts, 'timeout', 10000);
  this._prefix = normalizedPrefix(opts.scope);

  this._cache = opts.cache || {};
  var fgpt = opts.serverFingerprint;
  var adapter;
  if (fgpt) {
    adapter = this._cache[fgpt];
  }
  if (!adapter) {
    // This might happen even if the server fingerprint option was set, in
    // cases where the cache doesn't contain the corresponding adapter.
    fgpt = ptcl.getFingerprint();
    adapter = this._cache[fgpt] = new Adapter(ptcl, ptcl, fgpt);
  }
  this._adapter = adapter;

  this._registry = new Registry(this, PREFIX_LENGTH);
  this._destroyed = false;
  this._interrupted = false;
  this.once('_eot', function (pending) { this.emit('eot', pending); });
}
543002
function Emitter(conn) {
            if (!(this instanceof Emitter)) return new Emitter(conn);
            this.ids = 1;
            this.acks = {};
            this.conn = conn;
            if (this.conn) this.bind();
          }
329282
public function writeByteStream(Stream $stream, Stream $value)
    {
        $length = $value->getSize();

        $value->seek(0);
        $this->writeVarint($stream, $length);
        $stream->writeStream($value, $length);
    }
105171
public function setAdapter($adapter)
    {
        if (\is_callable($adapter)) {
            $adapter = \call_user_func($adapter, $this->container);
        }

        $this->adapter = $adapter;
    }
865473
function(options) {
	events.EventEmitter.call(this); 	// inherit from EventEmitter
    	TRACE 		= options.log;
	IDX 		= options.idx;
	STATUS 		= options.status;
	HOST 		= options.host;
	REQUEST		= options.request;
	this.domoMQTT	= this.connect(HOST);
}
1083969
public function channel($channel_id, $source_factory = null, $emitter_factory = null)
    {
        if (isset($this->channel_list[$channel_id])){
            return $this->channel_list[$channel_id];
        }

        $source = null;
        if ($source_factory){
            if (is_callable($source_factory)){
                $source = call_user_func($source_factory);
            }
            else if ($source_factory instanceof EventSourceFactoryInterface){
                $source = $source_factory->createEventSource();
            }
        }

        $emitter = null;
        if ($emitter_factory){
            if (is_callable($emitter_factory)){
                $emitter = call_user_func($emitter_factory);
            }
            else if ($emitter_factory instanceof EventSourceFactoryInterface){
                $emitter = $emitter_factory->createEventEmitter();
            }
        }

        $channel = new EventChannel($source, $emitter);
        $this->channel_list[$channel_id] = $channel;

        return $channel;
    }
1313381
protected void setStream(
    int priority,
    Reliability reliability,
    Stream stream) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "setStream",
        new Object[] { new Integer(priority), reliability, stream });
        
    ReliabilitySubset subset = getSubset(reliability);    
    subset.setStream(priority, stream);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "setStream");
  }
183549
public void addEmitter(ParticleEmitter emitter) {
		emitters.add(emitter);
		
		ParticlePool pool= new ParticlePool( this, maxParticlesPerEmitter );
		particlesByEmitter.put( emitter, pool );
	}
24458
public function set($key, $value)
    {
        if (! $value instanceof EmitterInterface) {
            throw new InvalidArgumentException(
                "Only EmitterInterface object can be putted in a ".
                "EmittersMap."
            );
        }
        return parent::set($key, $value);
    }
294762
public function setStream($streamName)
    {
        switch ($streamName) {
            case 'STDOUT':
                $this->stream = self::STDOUT;

                return;
            case 'STDERR':
                $this->stream = self::STDERR;

                return;
            default:
                LoggerPolicy::processConfigurationError("Stream must be STDOUT or STDERR, got '{$streamName}'");

                return;
        }
    }
852356
public function setFormatter(Formatter $formatter)
    {
        $this->output->setFormatter($formatter);
        $this->errorOutput->setFormatter($formatter);
    }
150170
public function setFormatter(Formatter $formatter)
    {
        $this->formatter = $formatter;
        $this->formatOutput = $this->stream->supportsAnsi() || !($formatter instanceof AnsiFormatter);
    }