Register Term Adapter.

@return void
507272
protected function registerTermAdapter()
    {
        $this->app->bind('adapter.term', function ($app) {
            return new Term($app['config']);
        });

        $this->app->alias('adapter.term', Term::class);
    }
235621
protected function registerLoader()
    {
        // to Translator
        $this->app->singleton('translation.loader', function ($app) {
            return new FileLoader($app['files'], $app['path.lang']);
        });

        // to Jargon
        $this->app->singleton('jargon.loader', function ($app) {
            return new FileLoader($app['files'], $app['path.jargon']);
        });
    }
741003
protected function registerConverter()
    {
        $this->app->singleton('converter', function ($app) {
            $measurements = $app['config']->get('cartalyst.converter.measurements');

            $converter = new Converter($app['converter.exchanger']);
            $converter->setMeasurements($measurements);

            return $converter;
        });
    }
435676
public function register()
  {
    $this->app->bind('acl', function($app){
      return new AclAdminControlPanel;
    });

    //Register dependency packages
    $this->app->register('Collective\Html\HtmlServiceProvider');
    $this->app->register('Intervention\Image\ImageServiceProvider');

    // Register dependancy aliases
    $this->app->booting(function()
    {
      $loader = \Illuminate\Foundation\AliasLoader::getInstance();
      $loader->alias('Form', 'Collective\Html\FormFacade');
      $loader->alias('HTML', 'Collective\Html\HtmlFacade');
      $loader->alias('Image', 'Intervention\Image\Facades\Image');
    });

  }
78894
public function registerAutoloader(){
        $aliasManager = $this;
        spl_autoload_register(function($class) use($aliasManager) {
            $class = strtolower($class);
            if( !$aliasManager->checkIfAliasExists($class) ){
                if( !$aliasManager->findAlias($class) ){
                    throw new Exception("Class was not found! ($class)");
                }
            }

            $aliasManager->loadAlias($class);
        });
    }
515599
protected function register()
    {
        // Setup taxonomy relationships.
        $this->relation();

        // Make taxonomy model for the factory.
        $this->setModel($this->makeTaxonomyModel());

        // Build taxonomy with model and singularity holders.
        $this->setSingularity($this->makeTaxonomyInstance());

        // Set fields to the taxonomy.
        if ($this->methodExist('fields')) {
            $this->registerFields();
        }

        // Set columns to the taxonomy, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
875826
public static function register()
    {
        if (!in_array(self::FILTERNAME, stream_get_filters(), true)) {
            stream_filter_register(self::FILTERNAME, self::class);
        }
    }
701497
public function register()
    {
        $this->app->singleton(Datatables::class);
        $this->app->singleton(GroupsFilterAdapter::class);
        $this->app->alias(Datatables::class, 'datatables');
    }
485945
public function register()
    {
        $this->app->bind('Setting', Setting::class);
        $this->app->bind(SettingStorageContract::class, EloquentStorage::class);
    }
535684
public function register()
    {
        if (!defined('ACACHA_PROFILE_PATH')) {
            define('ACACHA_PROFILE_PATH', realpath(__DIR__.'/../../'));
        }

        $this->app->bind('Profile', function () {
            return new \Acacha\Profile\Profile();
        });

        $this->mergeConfigFrom(
            ACACHA_PROFILE_PATH.'/config/profile.php', 'acacha-profile'
        );

        $this->app->register(ContactServiceProvider::class);
    }
1200160
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_taxonomy($_self->singular, $_self->post_types, $this->options);
		});

	}
321842
private void registerModelAdapter() {
        Dictionary<String, Object> properties = createResourceToModelAdapterProperties();
        String serviceClassName = AdapterFactory.class.getName();
        this.resourceToModelAdapterRegistration = this.context.registerService(serviceClassName, this.adapter, properties);
    }
393617
public function register()
    {
        // register class aliases
        $loader = AliasLoader::getInstance();
        $loader->alias('PageBuilder', PageBuilderFacade::class);

        // register container aliases
        $this->app->alias('pageBuilder', PageBuilderFactory::class);
        $this->app->alias('pageBuilder', PageBuilder::class);
    }
470140
public function register() {
        $this->registerFilesystemProvider();
        $this->registerDatabaseProvider();
        $this->registerCompressorProvider();
        $this->registerShellProcessor();
        $this->registerArtisanCommands();
    }
968463
public function register()
    {
        $this->registerAdapterFactory();
        $this->registerCacheFactory();
        $this->registerFlysystemFactory();
        $this->registerManager();
        $this->registerBindings();
    }
253107
public function register()
    {
        $loader = $this->app->make(ConfigurationLoader::class);

        $this->app->instance('config', $loader->getConfig());
        $this->app->alias('config', 'Illuminate\Config\Repository');
        $this->app->alias('config', 'Illuminate\Contracts\Config\Repository');
    }
1316305
public function register()
    {
        // Handle case-insensitivity of class names.
        $this->newClasses    = $this->arrayKeysToLowercase($this->newClasses);
        $this->newExceptions = $this->arrayKeysToLowercase($this->newExceptions);

        // Add the Exception classes to the Classes list.
        $this->newClasses = array_merge($this->newClasses, $this->newExceptions);

        $targets = array(
            \T_NEW,
            \T_CLASS,
            \T_DOUBLE_COLON,
            \T_FUNCTION,
            \T_CLOSURE,
            \T_CATCH,
        );

        if (\defined('T_ANON_CLASS')) {
            $targets[] = \T_ANON_CLASS;
        }

        if (\defined('T_RETURN_TYPE')) {
            $targets[] = \T_RETURN_TYPE;
        }

        return $targets;
    }