Sets sub processors

@param {array} processors Sub processors
@returns {metaProcessor} this

@throws {Error} if sub processor already exist

@this {metaProcessor}
961349
function(processors) {
        var that = this;
        _.each(processors, function(processor, name) {
            if (name in that._processors) {
                throw new Error('Processor "' + name + '" already exists!');
            }
            that._processors[name] = processor;
        });

        return this;
    }
1057931
def set_parallelism(self, num_instances):
        
        assert (num_instances > 0)
        self.env._set_parallelism(self.src_operator_id, num_instances)
        return self
418601
def set_cpus(self, cpus=0):
        
        from multiprocessing import cpu_count

        max_cpus = cpu_count()
        if not 0 < cpus < max_cpus:
            cpus = max_cpus
        self.add_option("--cpus", default=cpus, type="int",
                     help="Number of CPUs to use, 0=unlimited [default: %default]")
1241856
@NonNull
    public IconicsAnimatedDrawable processors(@NonNull IconicsAnimationProcessor... processors) {
        if (processors == null || processors.length == 0) return this;
        for (IconicsAnimationProcessor processor : processors) {
            processor(processor);
        }
        return this;
    }
1219790
@Override
	public Processor newProcessor(Processor p) {
		AMRulesAggregatorProcessor oldProcessor = (AMRulesAggregatorProcessor) p;
		Builder builder = new Builder(oldProcessor);
		AMRulesAggregatorProcessor newProcessor = builder.build();
		newProcessor.resultStream = oldProcessor.resultStream;
		newProcessor.statisticsStream = oldProcessor.statisticsStream;
		return newProcessor;
	}
454254
function callProcessor(eventType, data, callback) {
    var p = processors[eventType];
    // no processors
    if (p===undefined || p.length==0) {
      if (callback!==undefined) callback(data);
      return;
    }
    // now go through all processors
    var n = 0;
    var cbCalled = false;
    var cb = function(inData) {
      if (cbCalled) throw new Error("Internal error in "+eventType+" processor. Callback is called TWICE.");
      cbCalled = true;
      if (n < p.length) {
        cbCalled = false;
        p[n++](inData, cb);
      } else {
        if (callback!==undefined) callback(inData);
      }
    };
    cb(data);
  }
99399
public EventHandlerGroup<T> and(final EventProcessor... processors)
    {
        Sequence[] combinedSequences = new Sequence[sequences.length + processors.length];

        for (int i = 0; i < processors.length; i++)
        {
            consumerRepository.add(processors[i]);
            combinedSequences[i] = processors[i].getSequence();
        }
        System.arraycopy(sequences, 0, combinedSequences, processors.length, sequences.length);

        return new EventHandlerGroup<>(disruptor, consumerRepository, combinedSequences);
    }
1334629
function Queue( subQueues ) {
  subQueues = subQueues || [];
  subQueues.push('default');
  subQueues = _.uniq(subQueues);

  this.queueNames = subQueues;
  this.__queues__ = {};

  subQueues.forEach(function( name ) {
    this.__queues__[name] = new SubQueue();
  }.bind(this));
}
330158
def register_default_processors(cls, frontend_editing=None):
        
        super(Page, cls).register_default_processors()

        if frontend_editing:
            cls.register_request_processor(
                edit_processors.frontendediting_request_processor,
                key='frontend_editing')
            cls.register_response_processor(
                edit_processors.frontendediting_response_processor,
                key='frontend_editing')
128769
function Processor(options) {
    options = options || {};
    this.files = options.files || FILES;
    this.from  = options.from || DIR_FROM;
    this.to = options.to || DIR_TO;
    this.clear = options.clear || false;
}
1130271
public void setSubnets(java.util.Collection<Subnet> subnets) {
        if (subnets == null) {
            this.subnets = null;
            return;
        }

        this.subnets = new java.util.ArrayList<Subnet>(subnets);
    }
77176
public T withProcessor(final NiftyProcessor processor)
    {
        this.niftyProcessorFactory = new NiftyProcessorFactory() {
            @Override
            public NiftyProcessor getProcessor(TTransport transport)
            {
                return processor;
            }
        };
        return (T) this;
    }
343675
function processor() {
    var destination = unified()
    var length = attachers.length
    var index = -1

    while (++index < length) {
      destination.use.apply(null, attachers[index])
    }

    destination.data(extend(true, {}, namespace))

    return destination
  }
411003
@Override
    public Processor newProcessor(Processor sourceProcessor) {
        PredictionCombinerProcessor newProcessor = new PredictionCombinerProcessor();
        PredictionCombinerProcessor originProcessor = (PredictionCombinerProcessor) sourceProcessor;
        if (originProcessor.getOutputStream() != null) {
            newProcessor.setOutputStream(originProcessor.getOutputStream());
        }
        newProcessor.setSizeEnsemble(originProcessor.getSizeEnsemble());
        return newProcessor;
    }
766226
def use(processor, options = {})
      @stack << [self.class.get_callable(processor, Roger::Release::Processors.map), options]
    end
845980
function lookupProcessor(list) {
	if (list instanceof Node)
		return returnText;

	var lookup = list[0];
	if (lookup instanceof Array) {
		return processors.fncall;
	}

	// TODO: evaluate the sanity of this.
	if (list[0].type == "string" || list[0].type == "number")
		return processors.refprop;

	var processor = macros[lookup.key];
	if (processor) return processor;

	processor = processors[lookup.key];
	if (processor) return processor;

	processor = processors[lookup.type];
	if (processor) return processor;

	return processors.fncall;
}
1164672
function init(config) {
            this.storage = {};
            if (typeof config !== 'undefined') {
                Object.keys(config).forEach(function (property) {
                    this[property] = config[property];
                }, this);
            }

            if(this.processors instanceof Array === false){
                this.processors = [].concat(this.constructor.processors);
            }
			if(this.preprocessors instanceof Array === false){
                this.preprocessors = [].concat(this.constructor.preprocessors);
            }
        }