Registers CronField in ParserDefinitionBuilder and returns its instance.

@return ParserDefinitionBuilder instance obtained from constructor
777149
@Override
    public CronDefinitionBuilder and() {
        final boolean zeroInRange = constraints.createConstraintsInstance().isInRange(0);
        cronDefinitionBuilder
                .register(new DayOfWeekFieldDefinition(fieldName, constraints.createConstraintsInstance(), optional, new WeekDay(mondayDoWValue, zeroInRange)));
        return cronDefinitionBuilder;
    }
736735
public CronField parse(final String expression) {
        return new CronField(field, parser.parse(expression), constraints);
    }
993193
public function registerDecorator()
    {
        $this->app->singleton('presenter.decorator', function ($app) {
            $decorator = new Decorator();

            // This isn't really doing anything here however if you want to extend the decorator
            // with your own instance then you need to do it like this in your own service
            // provider or in start/global.php.
            Presenter::setExtendedDecorator($decorator);

            return $decorator;
        });
    }
251636
public function getRequestHandlerBuilder(){
        if(null === $this->requestHandlerBuilder){
            $this->requestHandlerBuilder    = new RequestHandlerBuilder(
                $this->getContainer()
            );

            foreach($this->bundles as $bundle){
                if($bundle instanceof Bundle\MiddlewareRegisterInterface){
                    $bundle->middlewareRegister($this->requestHandlerBuilder);
                }
            }
        }

        return clone $this->requestHandlerBuilder;
    }
971846
protected function registerProfileBuilder()
    {
        $this->app->singleton('backup.builder', function (Container $app) {
            $config = $app['config']['backup'];

            $factory = new ProfileBuilderFactory($app);

            return $factory->make($config);
        });

        $this->app->alias('backup.builder', ProfileBuilder::class);
    }
429674
public function register($prepend = false)
    {

        if ($this->isRegistered())
            return $this;

        try {
            
            spl_autoload_register($this->handle, true, $prepend);
        } catch(\Exception $e) {

            throw new \RuntimeException(
                "Failed to register ".static::class." as a SPL autoloader (spl_autoload_register())", 0, $e
            );
        }

        return parent::register($prepend);
    }
266577
public function getConfigTreeBuilder()
	{
		$treeBuilder = new TreeBuilder();

		$treeBuilder->root('framework')
				->children()
					->append($this->getLocalesDefinition())
					->append($this->getDoctrineDefinition())
					->append($this->getAuditDefinition())
					->append($this->getSessionDefinition())
					->append($this->getMailerDefinition())
					->append($this->getServicesDefinition())
				->end();

		return $treeBuilder;
	}
387366
protected function registerPeriodManagementInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Services\PeriodManagement\PeriodManagementInterface', function($app)
		{
			return new PeriodManager(
				$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
				$app->make('App\Kwaai\Security\Services\JournalManagement\JournalManagementInterface'),
				$app->make('App\Kwaai\Security\Repositories\Journal\JournalInterface'),
				new	\Mgallegos\LaravelJqgrid\Encoders\JqGridJsonEncoder($app->make('excel')),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\Period\EloquentPeriodGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Period\PeriodInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\JournalVoucherInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\FiscalYear\FiscalYearInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Setting\SettingInterface'),
				new Carbon(),
				$app['db'],
				$app['translator'],
				$app['config']
			);
		});
	}
568985
protected function registerPeriodInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\Period\PeriodInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\Period\EloquentPeriod(new Period(), $app['db'], $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
181043
public function registerSearchBuilder()
    {
        $this->app->singleton('searchy', function (Container $app) {
            $config = $app['config'];

            return new SearchBuilder($config);
        });

        $this->app->alias('searchy', SearchBuilder::class);
    }
271781
public function createTwigEnvironmentBuilder()
    {
        $this->ensureCsrfTokenManagerAndTranslatorExist();
        $builder = new TwigEnvironmentBuilder();
        return $builder->setCsrfTokenManager($this->csrf_token_manager)->setTranslator($this->translator);
    }
532354
public function register()
    {
        $this->app->singleton('command.queue.cron', function ($app) {
            return new CronCommand($app['queue.worker']);
        });

        $this->commands('command.queue.cron');
        $this->app->singleton('queue.worker', function ($app) {
            return new CronWorker($app['queue'], $app['queue.failer'], $app['events']);
        });
    }
705371
public function registerIndexSingleton()
    {
        $this->app->singleton(Index::class, function ($app) {

            $settings = new IndexSettings(
                config('elasticsearch.index'),
                config('elasticsearch.settings'),
                config('elasticsearch.mappings')
            );

            $settings->setIndexables(config('elasticsearch.indexables'));

            return new Index($app[Client::class], $settings);
        });
    }
1209900
protected function registerUrlGenerator()
    {
        $this->app->singleton('url', function ($app) {
            $routes = $app['router']->getRoutes();

            // The URL generator needs the route collection that exists on the router.
            // Keep in mind this is an object, so we're passing by references here
            // and all the registered routes will be available to the generator.
            $app->instance('routes', $routes);

            $url = new UrlGenerator(
                $routes, $app->rebinding(
                    'request', $this->requestRebinder()
                ), $app['config']['app.asset_url']
            );

            // Next we will set a few service resolvers on the URL generator so it can
            // get the information it needs to function. This just provides some of
            // the convenience features to this URL generator like "signed" URLs.
            $url->setSessionResolver(function () {
                return $this->app['session'];
            });

            $url->setKeyResolver(function () {
                return $this->app->make('config')->get('app.key');
            });

            // If the route collection is "rebound", for example, when the routes stay
            // cached for the application, we will need to rebind the routes on the
            // URL generator instance so it has the latest version of the routes.
            $app->rebinding('routes', function ($app, $routes) {
                $app['url']->setRoutes($routes);
            });

            return $url;
        });
    }
1127295
protected function registerUrlGenerator()
    {
        $this->app->singleton('api.url', function ($app) {
            $url = new UrlGenerator($app['request']);

            $url->setRouteCollections($app[Router::class]->getRoutes());

            $url->setKeyResolver(function () {
                return $this->app->make('config')->get('app.key');
            });

            return $url;
        });
    }
276269
public function register()
    {
        foreach ($this->singletonClassMap as $abstract => $concrete)
        {
            $this->app->singleton($abstract, function() use ($concrete)
            {
                return $this->app->make($concrete);
            });
        }
    }
1092928
public function addCallableHandle()
    {
        if ($this->handler) {
            throw new AlreadyBuildedException('The handler already builded.');
        }

        $loader = new CallableLoader();
        $resolver = new CallableResolver();

        $this->addCallableResolver($resolver);
        $this->addActionLoader($loader);

        return $loader;
    }