Registers the time provider with the appropriate managers. Called by the presents server at
startup.
342868
public static void init (InvocationManager invmgr, RootDObjectManager omgr)
    {
        // we'll need these later
        _invmgr = invmgr;
        _omgr = omgr;

        // register a provider instance
        invmgr.registerProvider(new TimeBaseProvider(), TimeBaseMarshaller.class, GLOBAL_GROUP);
    }
1035876
public function registerConfiguredProviders()
	{
		$manifestPath = $this->getCachedServicesPath();

		(new ProviderRepository($this, new Filesystem, $manifestPath))
					->load($this->config['app.providers']);
	}
387583
protected function registerManager()
	{
		$me = $this;

		$this->app->bindShared('queue', function($app) use ($me)
		{
			// Once we have an instance of the queue manager, we will register the various
			// resolvers for the queue connectors. These connectors are responsible for
			// creating the classes that accept queue configs and instantiate queues.
			$manager = new QueueManager($app);

			$me->registerConnectors($manager);

			return $manager;
		});
	}
703875
protected function registerManager()
    {
        $this->container->singleton('queue', function ($container) {
            // Once we have an instance of the queue manager, we will register the various
            // resolvers for the queue connectors. These connectors are responsible for
            // creating the classes that accept queue configs and instantiate queues.
            return tap(new QueueManager($container), function ($manager) {
                $this->registerConnectors($manager);
            });
        });
    }
815958
protected function registerDefaultProviders() {

		array_map( function( $provider ) {
			$this->provider( $provider );
		}, [
			AttrServiceProvider::class,
			LanguageServiceProvider::class,
			MetaServiceProvider::class,
			TemplatesServiceProvider::class,
			HierarchyServiceProvider::class,
			ViewServiceProvider::class
		] );
	}
502831
public void registerProvider(Object provider) {
		if (provider != null) {
			Collection<Object> providerList = new ArrayList<>(1);
			providerList.add(provider);
			registerProviders(providerList);
		}
	}
286005
protected function registerManagerStopCallback()
    {
        $this->swooleServer->on('ManagerStop', function () {
            $this->events->dispatch(new Events\ManagerStopped($this));

            $this->dispatchEvent('ManagerStop', $this);
        });
    }
1039978
protected function registerManagerStartCallback()
    {
        $this->swooleServer->on('ManagerStart', function () {
            $this->setProcessName("{$this->app->name()} : Manager");

            $this->events->dispatch(new Events\ManagerStarted($this));

            $this->dispatchEvent('ManagerStart', $this);
        });
    }
1068982
private function registerProviders()
    {
        $providers = $this->config('app')['providers'];
        foreach ($providers as $provider) {
            $obj = new $provider($this);

            if (!$obj instanceof Provider) {
                throw new \Exception("Invalid provider: $provider");
            }

            $this->container->invoke($obj, 'register');
        }
    }
156414
public function registerWorker()
    {
        Resque::redis()->sadd('workers', $this);
        Resque::redis()->set('worker:' . (string)$this . ':started', strftime('%a %b %d %H:%M:%S %Z %Y'));
    }
1352932
def register(self, collector):
        """"""
        with self._lock:
            names = self._get_names(collector)
            duplicates = set(self._names_to_collectors).intersection(names)
            if duplicates:
                raise ValueError(
                    'Duplicated timeseries in CollectorRegistry: {0}'.format(
                        duplicates))
            for name in names:
                self._names_to_collectors[name] = collector
            self._collector_to_names[collector] = names
980630
protected function registerStartCallback()
    {
        $this->swooleServer->on('Start', function () {
            $this->setProcessName("{$this->app->name()} : Master");

            $this->events->dispatch(new Events\ServerStarted($this));

            $this->dispatchEvent('Start', $this);
        });
    }
365382
protected function registerTimeInTransit()
    {
        $this->app->singleton('ups.time-in-transit', function (Container $app) {
            $config = $app->config->get('ups');

            return new TimeInTransit(
                $config['access_key'],
                $config['user_id'],
                $config['password'],
                $config['sandbox'],
                null,
                $app->make('log')
            );
        });
    }
720289
def registerHandler(self, matcher, handler):
        '''
        
        '''
        self.handlers[matcher] = handler
        self.scheduler.register((matcher,), self)
        self._setDaemon()
390304
public function register()
    {   
        $providers = config('app','core_providers');
        foreach ($providers as $key => $value) {
            $this->getContainer()->add($value);
        }
    }
964717
private function registerServiceProviders()
    {
        $this->app->register( ArboryTranslationServiceProvider::class );
        $this->app->register( TranslatableServiceProvider::class );
        $this->app->register( ArboryFileServiceProvider::class );
        $this->app->register( ArboryAuthServiceProvider::class );
        $this->app->register( GlideImageServiceProvider::class );
        $this->app->register( AssetServiceProvider::class );
        $this->app->register( SettingsServiceProvider::class );
        $this->app->register( ExcelServiceProvider::class );
        $this->app->register( FileManagerServiceProvider::class );
    }
867999
private function registerServiceProviders()
    {
        foreach ($this->serviceProviders as $key => $serviceClass) {
            $this->container[$key] = $this->share(function () use ($serviceClass) {
                return $this->make($serviceClass);
            });
        }
    }