{@inheritDoc}
@see \n2n\web\dispatch\DynamicDispatchable::setup()
357512
public function setup(DispatchModel $dispatchModel) {
		foreach ($this->dispatchables as $key => $dispatchable) {
			$dispatchModel->addProperty(new ObjectProperty(new DynamicAccessProxy($key), false));
		}
	}
1169702
protected function setup($mode)
    {
        $this->mode = $mode;

        // Set up runtime options. Will be passed to all
        // subclasses.
        $options = ['fetchmode' => $this->fetchMode];

        if ($this->oldVersion) {
            $options['svn_path'] = $this->getSvnPath();
        } else {
            $options['binaryPath'] = $this->getSvnPath();
        }

        // Pass array of subcommands we need to factory
        $this->svn = VersionControl_SVN::factory($mode, $options);

        if (get_parent_class($this->svn) !== 'VersionControl_SVN_Command') {
            $this->oldVersion = true;
            $this->svn->use_escapeshellcmd = false;
        }

        if (!empty($this->repositoryUrl)) {
            $this->svnArgs = [$this->repositoryUrl];
        } else {
            if (!empty($this->workingCopy)) {
                if (is_dir($this->workingCopy)) {
                    $this->svnArgs = [$this->workingCopy];
                } else {
                    if ($mode == 'info') {
                        if (is_file($this->workingCopy)) {
                            $this->svnArgs = [$this->workingCopy];
                        } else {
                            throw new BuildException("'" . $this->workingCopy . "' is not a directory nor a file");
                        }
                    } else {
                        throw new BuildException("'" . $this->workingCopy . "' is not a directory");
                    }
                }
            }
        }
    }
388765
final public function setup()
    {
        if (!$this->setup) {
            // configure our datagrid
            $resolver = new OptionsResolver();
            $this->configureOptions($resolver);
            $this->options = $resolver->resolve($this->getOptions());

            $this->setup = true;
        }
    }
720982
public function setup(string $environment = null)
    {
        if (isset($this->initialized['setup'])) {
            return $this;
        }

        $this->initialized['setup'] = true;

        $this->measureTime('_setup', 'Site Setup', function () use ($environment) {
            // Force environment if passed to the method.
            if ($environment) {
                Setup::$environment = $environment;
            }

            $this['setup'];
            $this['streams'];
        });

        return $this;
    }
1013204
protected function setup(array $config = [])
    {
        if (!isset($config['data_provider'])) {
            throw new Exception(translate('{data_provider} must be a DatapPovider objetc'), 500, Exception::BADARGUMENTS);
        } elseif (isset($config['data_provider']) && !($config['data_provider'] instanceof DataProviderInterface)) {
            throw new Exception(translate('{data_provider} must be a DatapPovider objetc'), 500, Exception::BADARGUMENTS);
        }

        if (!isset($config['columns'])) {
            throw new Exception(translate('{columns} must be an array type Column[]'), 500, Exception::BADARGUMENTS);
        }

        parent::setup($config);

        $this->setupColumns();
    }
1038736
public function install(SchemaSetupInterface $setup, ModuleContextInterface $context)
    {
        $installer = $setup;

        $installer->startSetup();

        $this->installPostEntity($installer);
        $this->installCategoryEntity($installer);

        $table = $installer->getConnection()
            ->newTable($installer->getTable('mst_blog_category_post'))
            ->addColumn(
                'category_id',
                Table::TYPE_INTEGER,
                null,
                ['unsigned' => true, 'nullable' => false, 'primary' => true, 'default' => '0'],
                'Category ID'
            )->addColumn(
                'post_id',
                Table::TYPE_INTEGER,
                null,
                ['unsigned' => true, 'nullable' => false, 'primary' => true, 'default' => '0'],
                'Post ID'
            )->addIndex(
                $installer->getIdxName('mst_blog_category_post', ['post_id']),
                ['post_id']
            )->addForeignKey(
                $installer->getFkName(
                    'mst_blog_category_post',
                    'category_id',
                    'mst_blog_category_entity',
                    'entity_id'
                ),
                'category_id',
                $installer->getTable('mst_blog_category_entity'),
                'entity_id',
                Table::ACTION_CASCADE
            )->addForeignKey(
                $installer->getFkName(
                    'mst_blog_category_post',
                    'post_id',
                    'mst_blog_post_entity',
                    'entity_id'
                ),
                'post_id',
                $installer->getTable('mst_blog_post_entity'),
                'entity_id',
                Table::ACTION_CASCADE
            )->setComment('Blog Post To Category Linkage Table');
        $installer->getConnection()->createTable($table);

        $table = $installer->getConnection()
            ->newTable($installer->getTable('mst_blog_tag'))
            ->addColumn(
                'tag_id',
                Table::TYPE_INTEGER,
                null,
                ['identity' => true, 'nullable' => false, 'primary' => true],
                'Tag ID'
            )->addColumn(
                'name',
                Table::TYPE_TEXT,
                255,
                [],
                'Name'
            )->addColumn(
                'url_key',
                Table::TYPE_TEXT,
                255,
                [],
                'Url Key'
            )->setComment('Tag Table');
        $installer->getConnection()->createTable($table);

        $table = $installer->getConnection()
            ->newTable($installer->getTable('mst_blog_tag_post'))
            ->addColumn(
                'tag_id',
                Table::TYPE_INTEGER,
                null,
                ['unsigned' => true, 'nullable' => false, 'primary' => true, 'default' => '0'],
                'Tag ID'
            )->addColumn(
                'post_id',
                Table::TYPE_INTEGER,
                null,
                ['unsigned' => true, 'nullable' => false, 'primary' => true, 'default' => '0'],
                'Post ID'
            )->addColumn(
                'store_id',
                Table::TYPE_SMALLINT,
                null,
                ['unsigned' => true, 'nullable' => false, 'default' => '0'],
                'Store ID'
            )->addIndex(
                $installer->getIdxName('mst_blog_tag_post', ['post_id']),
                ['post_id']
            )->addForeignKey(
                $installer->getFkName(
                    'mst_blog_tag_post',
                    'post_id',
                    'mst_blog_post_entity',
                    'entity_id'
                ),
                'post_id',
                $installer->getTable('mst_blog_post_entity'),
                'entity_id',
                Table::ACTION_CASCADE
            )->setComment('Blog Post To Tag Linkage Table');
        $installer->getConnection()->createTable($table);
    }
575177
public function setup($config = [])
    {
        $path = toPath($config['path']);

        if (is_array($config)) {
            $this->setCache($config['name']);
            $this->setPath(CYGNITE_BASE.DS.$path.DS);
            $this->setCacheExtension($config['extension']);

            return $this;
        }

        $this->setCache($config);

        return $this;
    }
1188034
protected function prepareConfiguration(array $options=null)
    {
        $configuration = clone $this->configuration;
        if (is_array($options)) {
            $options = array_replace($configuration->all(), $options);
            $configuration = new Configuration($options);
        }
        return $configuration;
    }
146025
public function loadConfiguration(): void
	{
		parent::loadConfiguration();

		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('application'))
			->setFactory(MiddlewareApplication::class)
			->setArguments([new Statement('@' . $this->prefix('chain') . '::create')]);
	}
1281470
public function setUp()
    {
        if ($this->resource) {
            $this->stub = 'controller/resource';
        } elseif ($this->scaffold) {
            $this->stub = 'controller/scaffold';
            $this->scaffolder = new ControllerScaffolder($this->getClass(), $this->getPrefix());
        }
    }
1097385
public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('factory'))
			->setImplement(IStandaloneFormFactory::class);
	}
1354237
public function setup()
    {
        $app = $this->getApplication();

        $options = $app->config('doctrine');
        if (is_array($options)) {
            $this->setOptions($this->options, $options);
        }

        $proxyDir = $this->getOption('proxy_path');
        $cache = DoctrineCacheFactory::configureCache($this->getOption('cache_driver'));

        $config = Setup::createConfiguration(!!$app->config('debug'), $proxyDir, $cache);
        $config->setNamingStrategy(new UnderscoreNamingStrategy());

        $this->setupAnnotationMetadata();

        if (!$this->setupMetadataDriver($config)) {
            throw new \RuntimeException('No Metadata Driver defined');
        }
        $config->setAutoGenerateProxyClasses($this->getOption('auto_generate_proxies', true) == true);

        $connection = $this->getOption('connection');

        $app->container->singleton(
            'entityManager',
            function () use ($connection, $config) {
                return EntityManager::create($connection, $config);
            }
        );
    }
1315736
private function bind(array $configurations)
    {
        $configuratorFactory = clone $this->configuratorFactory;

        if (isset($configurations['crud'])) {
            /** @var CrudConfigurator $crudConfigurator */
            $crudConfigurator = $configuratorFactory->getConfigurator(CrudConfigurator::class);
            $crudConfigurator->setCrud($configurations['crud']);
            $configuratorFactory->addConfigurator($crudConfigurator);
        }

        if (isset($configurations['driver'])) {
            /** @var DriverConfigurator $driverConfigurator */
            $driverConfigurator = $configuratorFactory->getConfigurator(DriverConfigurator::class);
            $driverConfigurator->setDriver($configurations['driver']);
            $configuratorFactory->addConfigurator($driverConfigurator);
        }

        if (isset($configurations['grid'])) {
            /** @var GridConfigurator $gridConfigurator */
            $gridConfigurator = $configuratorFactory->getConfigurator(GridConfigurator::class);
            $gridConfigurator->setGrid($configurations['grid']);
            $configuratorFactory->addConfigurator($gridConfigurator);
        }

        if (isset($configurations['page'])) {
            /** @var PageConfigurator $pageConfigurator */
            $pageConfigurator = $configuratorFactory->getConfigurator(PageConfigurator::class);
            $pageConfigurator->setPage($configurations['page']);
            $configuratorFactory->addConfigurator($pageConfigurator);
        }

        if (isset($configurations['plugin'])) {
            /** @var PluginConfigurator $pluginConfigurator */
            $pluginConfigurator = $configuratorFactory->getConfigurator(PluginConfigurator::class);
            $pluginConfigurator->setPlugin($configurations['plugin']);
            $configuratorFactory->addConfigurator($pluginConfigurator);
        }

        if (isset($configurations['security'])) {
            /** @var SecurityConfigurator $securityConfigurator */
            $securityConfigurator = $configuratorFactory->getConfigurator(SecurityConfigurator::class);
            $securityConfigurator->setSecurity($configurations['security']);
            $configuratorFactory->addConfigurator($securityConfigurator);
        }

        if (isset($configurations['util'])) {
            /** @var UtilConfigurator $utilConfigurator */
            $utilConfigurator = $configuratorFactory->getConfigurator(UtilConfigurator::class);
            $utilConfigurator->setUtil($configurations['util']);
            $configuratorFactory->addConfigurator($utilConfigurator);
        }

        return $configuratorFactory;
    }
955653
protected function initConfiguration($tags, $categories, $limit, $presentAs, $paginated, $sorting)
    {
        $configuration = new ProviderConfiguration();
        $configuration->setTags($tags);
        $configuration->setCategories($categories);
        $configuration->setLimit($limit);
        $configuration->setPresentAs($presentAs);
        $configuration->setPaginated($paginated);
        $configuration->setSorting($sorting);

        return $configuration;
    }
1246095
public function setup() {
		$input_keys = array_keys((array) elgg_get_config('input'));
		$request_keys = array_keys((array) $_REQUEST);
		$keys = array_unique(array_merge($input_keys, $request_keys));
		foreach ($keys as $key) {
			if ($key) {
				$this->params->$key = get_input($key);
			}
		}
	}
491762
public function configure(...$definitions): ContainerConfiguration
    {
        $builder = new ContainerBuilder(ContainerConfiguration::class);

        $builder->useAutowiring(false)->useAnnotations(false)->ignorePhpDocErrors(false);

        $wiring = $this->config[WIRING] ?? null;
        if (fn\hasValue($wiring, [WIRING\REFLECTION, WIRING\AUTO])) {
            $builder->useAutowiring(true);
        } else if ($wiring === WIRING\STRICT) {
            $builder->useAnnotations(true)->ignorePhpDocErrors(false);
        } else if ($wiring === WIRING\TOLERANT) {
            $builder->useAnnotations(true)->ignorePhpDocErrors(true);
        }

        empty($this->config[CACHE]) || $builder->enableDefinitionCache();
        empty($this->config[PROXY]) || $builder->writeProxiesToFile(true, $this->config[PROXY]);
        empty($this->config[COMPILE]) || $builder->enableCompilation($this->config[COMPILE]);
        $this->container && $builder->wrapContainer($this->container);

        foreach ($definitions as $definition) {
            $builder->addDefinitions($definition);
        }

        /** @noinspection PhpUnhandledExceptionInspection */
        /** @noinspection PhpIncompatibleReturnTypeInspection */
        $built = $builder->build();
        return $built instanceof ContainerConfiguration
            ? $built
            : new ContainerConfiguration($built);
    }
658029
protected function setUp()
	{
		$this->bbcodeMonkey = new BBCodeMonkey($this->configurator);
		$this->collection   = new BBCodeCollection;
		$this->repositories = new RepositoryCollection($this->bbcodeMonkey);
		$this->repositories->add('default', __DIR__ . '/Configurator/repository.xml');
	}