Registers entity services.
197178
public function registerEntityServices() {

		$factory = Yii::$app->factory->getContainer();

		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IElementService', 'cmsgears\cms\common\services\entities\ElementService' );
		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IBlockService', 'cmsgears\cms\common\services\entities\BlockService' );

		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IMenuService', 'cmsgears\cms\common\services\entities\MenuService' );

		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IWidgetService', 'cmsgears\cms\common\services\entities\WidgetService' );
		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\ISidebarService', 'cmsgears\cms\common\services\entities\SidebarService' );

		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IPageService', 'cmsgears\cms\common\services\entities\PageService' );
		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IArticleService', 'cmsgears\cms\common\services\entities\ArticleService' );
		$factory->set( 'cmsgears\cms\common\services\interfaces\entities\IPostService', 'cmsgears\cms\common\services\entities\PostService' );
	}
563390
protected function registerSubscribeService(){

        $this->app->bind('designpond\newsletter\Newsletter\Repo\NewsletterSubscriptionInterface', function()
        {
            return new \designpond\newsletter\Newsletter\Repo\NewsletterSubscriptionEloquent(
                new \designpond\newsletter\Newsletter\Entities\Newsletter_subscriptions
            );
        });
    }
886362
public function register()
    {
        $this->registerConnectionServices();
        $this->registerEloquentFactory();
        $this->registerQueueableEntityResolver();

        Model::setConnectionResolver($this->container['db']);
        Model::setEventDispatcher($this->container['events']);
        Model::clearBootedModels();
        Model::observe(InternalObserve::class);
    }
864404
public void registerService(Object service)
    {
    	this.setService(service);
    	String serviceClass = getInterfaceClassName(); 

    	if (service != null)
    		serviceRegistration = context.registerService(serviceClass, this.service, properties);
    }
499961
protected function register()
    {
        // Make comment model for the factory.
        $this->setModel($this->makeUserModel());

        // Build comment with model.
        $this->setSingularity($this->makeUserInstance());

        // Set columns to the users, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
1358157
public function register()
    {
        $this->setupCache();
        $this->mergeConfig();
        $this->setupMetaData();
        $this->setupConnection();
        $this->registerManagerRegistry();
        $this->registerEntityManager();
        $this->registerClassMetaDataFactory();
        $this->registerExtensions();
        $this->registerCustomTypes();
        $this->registerPresenceVerifier();
        $this->registerConsoleCommands();
    }
330958
public function register()
    {
        $this->app->register('ProAI\Datamapper\Providers\MetadataServiceProvider');

        $this->registerEntityScanner();

        $this->registerSchemaBuilder();

        $this->registerModelGenerator();

        $this->registerCommands();
    }
1143199
public final void register() {
        synchronized (this) {
            if (filterFactoryServiceRegistration != null) {
                throw new IllegalStateException(String.format("%s [%s] has been registered.", getClass()
                    .getSimpleName(), this));
            }
            filterFactoryServiceRegistration = bundleContext.registerService(SERVICE_CLASSES, this, properties);
            LOGGER.info("Registered filterFactory for application {} with priority {}", getApplicationName(),
                getPriority());
        }
    }
602790
protected function registerServices(): void
	{
		// Register core services

		$this->serviceRegistrar('core');

		// Register environment specific services

		if($this->isCommandLine())
		{
			$this->registerCLIServices();
		}
		else
		{
			$this->registerWebServices();
		}
	}
951049
protected function registerCore()
	{
		// Bind the Entity Identifier aggregate.
	    $this->app->singleton(IdentifierServiceProvider::getProviderKey(), function($app)
	    {
	    	return new IdentifierService(IdentifierServiceProvider::getProviderKey(), new IdentifierDataSource(new IdentifierModel([], $this->getConnection())));
	    });

		// Bind the Entity Reference aggregate.
	    $this->app->singleton(ReferenceServiceProvider::getProviderKey(), function($app)
	    {
	    	return new ReferenceService(ReferenceServiceProvider::getProviderKey(), new ReferenceDataSource(new ReferenceModel([], $this->getConnection())));
	    });
	}
1059428
public void register(DescribeService service, String describeService) throws POIProxyException {
		serviceManager.registerServiceConfiguration(service.getId(), describeService, service);
	}
560018
protected function registerServices()
    {
        $this->app->singleton('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
283499
private function registerRobotsService()
    {
        $this->app->singleton('arcanedev.robots', Robots::class);

        $this->app->bind(
            \Arcanedev\Robots\Contracts\Robots::class,
            'arcanedev.robots'
        );
    }
695798
protected function registerServices()
    {
        $services = array_filter($this->config->get('app.services'), function ($service) {
            return class_exists($service);
        });

        foreach ($services as $service) {
            /** @var \Fyuze\Kernel\Service $obj */
            $obj = new $service($this->container);
            $obj->services();

            $this->services[] = $obj;
        }
    }
858100
public function register()
    {
        $this->setupConfig();

        $services = config('microservice.services');
        $currentEnv = app()->environment();

        /** @var array $services */
        foreach ($services as $service) {
            if ($service['enabled'] && $this->isInCurrentEnv($currentEnv, $service['environments'])) {
                if (array_get($service, 'config')) {
                    $this->app->configure($service['config']);
                }

                $this->app->register($service['provider']);
            }
        }

        app()->middleware(ConvertEmptyStringsToNull::class);
    }
417180
public function register()
    {
        // Set resolver for MySQL
        Connection::resolverFor('mysql', function ($connection, $database, $prefix = '', array $config = []) {
            $connection = new MySqlConnection($connection, $database, $prefix, $config);

            // Add Doctrine types for better support
            $this->addDoctrineTypes($connection);

            return $connection;
        });
    }
520488
protected function registerService()
    {
        $this->app->singleton('pragmarx.countries', function () {
            $hydrator = new Hydrator($config = new Config(config()));

            $cache = new Cache($config, app(config('countries.cache.service')));

            $helper = new Helper($config);

            $repository = new Repository($cache, $hydrator, $helper, $config);

            $hydrator->setRepository($repository);

            return new CountriesService($config, $cache, $helper, $hydrator, $repository);
        });
    }