Register the module.
340319
public function register()
    {
        $this->registerAliases();

        $this->registerProviders();

        if ($this->isLoadFilesOnBoot() === false) {
            $this->registerFiles();
        }

        $this->fireEvent('register');
    }
320446
public final function registerModule(Module $module)
    {
        $dependencies = $module->getModules();

        foreach($dependencies as $dependency){
            $this->registerModule($dependency);
        }

        $this->modules[$module->getModuleName()] = $module;
    }
51092
private function registerModuleRegistry()
    {
        $this->app->singleton( 'arbory', function ()
        {
            return new Admin(
                $this->app['sentinel'],
                new Menu(),
                new AssetPipeline()
            );
        } );

        $this->app->singleton( Admin::class, function ()
        {
            return $this->app['arbory'];
        } );
    }
699191
def register(self, *args):
        """"""

        super(ConfigurableMeta, self).register(*args)
        from hfos.database import configschemastore
        # self.log('ADDING SCHEMA:')
        # pprint(self.configschema)
        configschemastore[self.name] = self.configschema
994884
function register()
    {
        // Ensure the default options have been set.
        $customizedOptions = $this->model->getConfiguration() + array(
            'labels'              => array(),
            'supports'            => array('title', 'editor'),
            'hierarchical'        => false,
            'public'              => true,
            'show_ui'             => true,
            'show_in_menu'        => true,
            'show_in_nav_menus'   => false,
            'show_in_admin_bar'   => true,
            'menu_position'       => 5,
            'can_export'          => false,
            'has_archive'         => false,
            'exclude_from_search' => true,
            'publicly_queryable'  => true,
            'rewrite'             => array(),
            'capability_type'     => 'post',
        );

        $customizedOptions['rewrite'] += array(
            'with_front' => false,
        );


        $labelParser = new LabelParser($this->model);
        $labelParser->parse();
        $singular   = $labelParser->singular();
        $plural     = $labelParser->plural();

        $customizedOptions['labels'] += array(
            'name'                => _x($plural, 'Post Type General Name', 'strata'),
            'singular_name'       => _x($singular, 'Post Type Singular Name', 'strata'),
            'menu_name'           => __($plural, 'strata'),
            'parent_item_colon'   => __($singular. ' Item:', 'strata'),
            'all_items'           => __('All ' . $plural, 'strata'),
            'view_item'           => __('View ' . $singular. ' Item', 'strata'),
            'add_new_item'        => __('Add New', 'strata'),
            'add_new'             => __('Add New', 'strata'),
            'edit_item'           => __('Edit ' . $singular, 'strata'),
            'update_item'         => __('Update ' . $singular, 'strata'),
            'search_items'        => __('Search ' . $plural, 'strata'),
            'not_found'           => __('Not found', 'strata'),
            'not_found_in_trash'  => __('Not found in Trash', 'strata'),
        );

        return register_post_type($this->model->getWordpressKey(), $customizedOptions);
    }
785703
public function register()
    {
        $packages = $this->repository->enabled();

        $packages->each(function($properties)
        {
            $this->registerServiceProvider($properties);
        });
    }
619442
public function register()
    {
        foreach ($this->modules as $module) {
            if ($aggregator = $module->getAttribute('aggregator')) {
                $this->container->register($aggregator);
            }
        }

        return $this;
    }
165843
public function register()
    {
        $this->bindGuzzle();

        $this->bindAuth();

        $this->bindHttpClient();

        $this->bindApiClient();

        $this->bindTaxonomyMapper();
    }
481880
public function register()
    {
        $this->registerRouter();

        $this->registerUrlGenerator();

        $this->registerRedirector();

        $this->registerResponseFactory();

        $this->registerControllerDispatcher();
    }
341006
public function register() {
    $this->registerMiddleware();

    $this->app->before($this->createBeforeFilter());
    $this->app->after($this->createAfterFilter());
  }
1288139
def register_template(self, module):
        
        parameter_module = importlib.import_module(module)
        parameter_template = parameter_module.template()
        self.parameter_map[parameter_template.__class__.__name__.upper()] = \
            parameter_template
203929
protected function register()
    {
        if (function_exists('register_extended_post_type')) {
            register_extended_post_type($this->name, $this->args);
        } else {
            register_post_type($this->name, $this->args);
        }
    }
920589
private function bootModules()
    {
        foreach ($this->app['modules']->enabled() as $module) {
            $this->registerViewNamespace($module);
            $this->registerLanguageNamespace($module);
            $this->registerConfigNamespace($module);
        }
    }
239821
function register(Module, selector) {
  const _selector = getSelector(Module, selector);

  validate(Module, _selector);

  const methods = OdoModuleMethods(Module, _selector);

  // Apply OdoModule static methods.
  Object.keys(methods).forEach((method) => {
    Module[method] = methods[method];
  });

  // Apply the OdoModule static property.
  Module.Instances = new Map();

  // Internally register the module.
  store.set(_selector, Module);

  return Module;
}
958263
private function register() {

		$this->options['labels'] = $this->label;
		if (!isset($this->options['rewrite'])) {
			$this->options['rewrite'] = array('slug' => $this->singular);
		}

		$_self = &$this;

		add_action('init', function () use (&$_self) {
			register_post_type($_self->singular, $_self->options);
		});

	}
999322
public function register()
	{
		$this->app['arguments'] = function($app)
		{
			global $argv;

			// Register namespace for App commands and component commands
			// @FIXME: neither of these work yet...
			Arguments::registerNamespace('\App\Commands');
			Arguments::registerNamespace('\Components\{$1}\Cli\Commands');

			return new Arguments($argv);
		};
	}
981901
public function register()
	{
		$logger = new Writer(
			new Logger($this->app['env']), $this->app['events']
		);

		$this->app->instance('log', $logger);

		// If the setup Closure has been bound in the container, we will resolve it
		// and pass in the logger instance. This allows this to defer all of the
		// logger class setup until the last possible second, improving speed.
		if (isset($this->app['log.setup']))
		{
			call_user_func($this->app['log.setup'], $logger);
		}
	}