Configure the processors

@param  array $processors Array of processor options
778782
protected function configureProcessors(array $processors)
    {
        foreach ($processors as $processorName => $processorOptions) {
            $processorLoader = new ProcessorLoader($processorOptions, $this->processors);
            $this->processors[$processorName] = $processorLoader->load();
        }
    }
366206
public function manage_messageoutputs($processors) {
        // Display the current workflows
        $table = new html_table();
        $table->attributes['class'] = 'admintable generaltable';
        $table->data        = array();
        $table->head        = array(
            get_string('name'),
            get_string('enable'),
            get_string('settings'),
        );
        $table->colclasses = array(
            'displayname', 'availability', 'settings',
        );

        foreach ($processors as $processor) {
            $row = new html_table_row();
            $row->attributes['class'] = 'messageoutputs';

            $name = new html_table_cell(get_string('pluginname', 'message_'.$processor->name));
            $enable = new html_table_cell();
            if (!$processor->available) {
                $enable->text = html_writer::nonempty_tag('span', get_string('outputnotavailable', 'message'),
                    array('class' => 'error')
                );
            } else {
                $enable->text = html_writer::checkbox($processor->name, $processor->id, $processor->enabled, '',
                    array('id' => $processor->name)
                );
            }
            // Settings
            $settings = new html_table_cell();
            if ($processor->available && $processor->hassettings) {
                $settingsurl = new moodle_url('/admin/settings.php', array('section' => 'messagesetting'.$processor->name));
                $settings->text = html_writer::link($settingsurl, get_string('settings', 'message'));
            }

            $row->cells = array($name, $enable, $settings);
            $table->data[] = $row;
        }
        return html_writer::table($table);
    }
1103850
public function build(ProcessorInterface $processor = null): PipelineInterface
    {
        try {
            $config = [
                'stages' => $this->stages
            ];

            if ($processor !== null) {
                $config['processor'] = $processor;
            }
            return $this->createPipeline(
                $this->prepareConfig($config)
            );
        } catch (\Exception $e) {
            throw new InvalidArgumentException($e->getMessage());
        }
    }
1277949
public function setControllers(array $controllers)
	{
	    foreach ($controllers as $name => $controller) {
	        $this->setController($name, $controller);
	    }
	}
90122
protected function configureLoggers(array $loggers)
    {
        foreach ($loggers as $loggerName => $loggerOptions) {
            $loggerLoader = new LoggerLoader($loggerName, $loggerOptions, $this->handlers, $this->processors);
            $this->loggers[$loggerName] = $loggerLoader->load();
        }
    }
1238501
protected function setServiceKeys($keys = [])
    {
        $allkeys = $this->getKeys();
        $serviceKey = $this->getCacheKey();

        $allkeys[$serviceKey] = $keys;

        CacheFacade::forever($this->cacheIndexKey, $allkeys);
    }
300834
public function setProcessor(string $processorId, callable $processor): self
    {
        $this->_processors[$processorId] = $processor;

        return $this;
    }
65629
public function setTables($tables) {
		foreach($tables as $key=>$value) {
			if (is_numeric($key)) {
				$this->tables[] = $value;
			}
			else {
				$this->tables[] = $key;
				$this->columns[$key] = $value;
			}
		}
		$this->cacheTables = true;
	}
61531
public function configure(array $properties)
    {
        foreach ($properties as $name => $value) {
            $methodName = 'set' . ucfirst(strtolower($name));
            if (method_exists($this, $methodName)) {
                $this->$methodName($value);
            }
        }
    }
973824
protected function configure(array $options): void
    {
        $options = array_merge([
            'timeout_socket' => self::TIMEOUT_SOCKET,
        ], $options);

        parent::configure($options);
    }
1019309
public function registerProcessor(string $class, string $processorClass): void
    {
        if (! (new \ReflectionClass($processorClass))->implementsInterface(ProcessorInterface::class)) {
            throw InvalidArgumentException::create(InvalidArgumentException::INVALID_PROCESSOR_INTERFACE_CLASS, $processorClass);
        }

        if (! isset($this->processors[$class])) {
            $this->processors[$class] = $processorClass;
        } elseif (! is_array($this->processors[$class])) {
            $this->processors[$class] = [$this->processors[$class], $processorClass];
        } else {
            $this->processors[$class][] = $processorClass;
        }
    }
705944
public function configureServers(array $servers): array
    {
        return array_map(
            static function ($item) {
                if ($item['basic']) {
                    $item['basic'] = base64_encode($item['basic']);
                }

                return $item;
            },
            $servers
        );
    }
1175342
public function setProcessorsStack(array $stack)
    {
        $this->processorsStack = [];
        foreach (array_reverse($stack) as $processor) {
            $this->pushProcessor($processor);
        }

        return $this;
    }
1070361
private function addProcessors(array $processors)
    {
        // We need to reverse the array because Monolog "pushes" processors to top of the stack
        foreach (array_reverse($processors) as $processor) {
            $this->logger->pushProcessor($processor);
        }
    }
1029621
public function validate(array $data)
    {
        $processor = new Processor();
        self::setData($data);
        $configuration = $processor->processConfiguration($this, $data);
    }
346534
public function setStreamWriters(array $writers)
    {
        foreach ($writers as $key => $writer) {
            $this->setStreamWriter($key, $writer);
        }

        return $this;
    }
56553
public function setRenderers(array $renderers)
    {
        $this->renderers = [];

        foreach ($renderers as $renderer) {
            $this->addRenderer($renderer);
        }

        return $this;
    }