Register the taxonomy.

@return TaxonomyInterface
3053
public function set(): TaxonomyInterface
    {
        if (function_exists('current_filter') && 'init' === $hook = current_filter()) {
            $this->register();
        } else {
            $this->action->add('init', [$this, 'register']);
        }

        return $this;
    }
1078169
public function register()
    {
        $this->app->singleton(
            'datatables.fractal', function () {
                $fractal = new Manager;
                $config  = $this->app['config'];
                $request = $this->app['request'];

                $includesKey = $config->get('datatables-fractal.includes', 'include');
                if ($request->get($includesKey)) {
                    $fractal->parseIncludes($request->get($includesKey));
                }

                $serializer = $config->get('datatables-fractal.serializer', DataArraySerializer::class);
                $fractal->setSerializer(new $serializer);

                return $fractal;
            }
        );

        $this->app->singleton(
            'datatables.transformer', function () {
                return new FractalTransformer($this->app->make('datatables.fractal'));
            }
        );

        $this->commands(
            [
                TransformerMakeCommand::class,
            ]
        );
    }
227679
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/config.php', 'litecms.pricelist');

        // Bind facade
        $this->app->bind('litecms.pricelist', function ($app) {
            return $this->app->make('Litecms\Pricelist\Pricelist');
        });

        // Bind PriceList to repository
        $this->app->bind(
            'Litecms\Pricelist\Interfaces\PriceListRepositoryInterface',
            \Litecms\Pricelist\Repositories\Eloquent\PriceListRepository::class
        );

        $this->app->register(\Litecms\Pricelist\Providers\AuthServiceProvider::class);

        $this->app->register(\Litecms\Pricelist\Providers\RouteServiceProvider::class);

    }
450346
protected function registerSystemAccountTypeInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\System\Repositories\AccountType\AccountTypeInterface', function()
		{
			return new \Mgallegos\DecimaAccounting\System\Repositories\AccountType\EloquentAccountType( new SystemAccountType() );
		});
	}
812392
public function register()
    {
        $this->registered = true;

        return $this->registrar->register(
            $this->name, $this->controller, $this->options
        );
    }
1125391
public function register() {
        if (!$this->registered) {
            spl_autoload_register([$this, 'autoLoad'], $throw=true, $prepend=false);
            $this->registered = true;
        }
        return $this;
    }
551846
protected function registerDocumentTypeInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\DocumentType\DocumentTypeInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\DocumentType\EloquentDocumentType(new DocumentType(), $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
1121111
protected function registerService()
	{
	    $this->app->singleton($this->getProviderKey(), function($app)
	    {
	    	return new Service($this->getProviderKey(), new DataSource(new Model()));
	    });
	}
1073216
public function registerTaxonomy() {
        $namePlural = __('Topics', 'customer-feedback');
        $nameSingular = __('Topic', 'customer-feedback');

        $labels = array(
            'name'              => $namePlural,
            'singular_name'     => $nameSingular,
            'search_items'      => sprintf(__('Search %s', 'customer-feedback'), $namePlural),
            'all_items'         => sprintf(__('All %s', 'customer-feedback'), $namePlural),
            'parent_item'       => sprintf(__('Parent %s:', 'customer-feedback'), $nameSingular),
            'parent_item_colon' => sprintf(__('Parent %s:', 'customer-feedback'), $nameSingular) . ':',
            'edit_item'         => sprintf(__('Edit %s', 'customer-feedback'), $nameSingular),
            'update_item'       => sprintf(__('Update %s', 'customer-feedback'), $nameSingular),
            'add_new_item'      => sprintf(__('Add New %s', 'customer-feedback'), $nameSingular),
            'new_item_name'     => sprintf(__('New %s Name', 'customer-feedback'), $nameSingular),
            'menu_name'         => $nameSingular,
        );

        $args = array(
            'hierarchical'      => false,
            'labels'            => $labels,
            'show_ui'           => true,
            'show_admin_column' => true,
            'query_var'         => true,
            'meta_box_cb'       => false,
            'rewrite'           => array('slug' => 'topic'),
        );

        register_taxonomy('feedback_topic', array($this->postTypeSlug), $args);
    }
56658
public static function registerTaxonomies()
    {
        global $taxonomies_infos;
        if (!Arr::iterable($taxonomies_infos)) {
            return 0;
        }
        
        // Start by grouping all taxonomy requests by taxonomy key
        $count = 0;
        $grouped = Collection::groupBy($taxonomies_infos, 'key');
        foreach ($grouped as $key => $key_taxonomies) {
            // Now get all the post types
            $post_types = Collection::pluck($key_taxonomies, 'post_type');
            $configs = Collection::pluck($key_taxonomies, 'config');
            
            // Now we can finally register this taxonomy
            register_taxonomy($key, $post_types, current($configs));
            
            $count++;
        }
        return $count;
    }
189745
protected function registerRepository()
    {
        $this->app->singleton('neoeloquent.migration.repository', function($app)
        {
            $model = new MigrationModel;

            $label = $app['config']['database.migrations_node'];

            if (isset($label)) {
                $model->setLabel($label);
            }

            return new DatabaseMigrationRepository(
                $app['db'],
                $app['db']->connection('neo4j')->getSchemaBuilder(),
                $model
            );
        });
    }
104556
public function register()
    {
        if (! $this->isRegistered) {
            spl_autoload_register([$this, 'load'], true, true);
            $this->isRegistered = true;
        }

        return $this;
    }
1018431
public function registerTaxonomies()
    {

        if (!function_exists('register_taxonomy')) {
            return;
        }

        $this->taxonomies->rewind();
        while ($this->taxonomies->valid()) {

            $taxonomy = $this->taxonomies->current();
            register_taxonomy($taxonomy->getName(), $taxonomy->getSupportedPostTypes(), $taxonomy->getArgs());
            $this->taxonomies->next();

        }

    }
1261109
public function register()
    {
        // Handle case-insensitivity of interface names.
        $this->internalInterfaces = $this->arrayKeysToLowercase($this->internalInterfaces);

        $targets = array(\T_CLASS);

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

        return $targets;
    }
415583
public function registerTaxonomyToObjects()
    {
        // register Taxonomy to each of the PostTypes assigned
        if (!empty($this->posttypes)) {
            foreach ($this->posttypes as $posttype) {
                register_taxonomy_for_object_type($this->name, $posttype);
            }
        }
    }
593938
protected function registerFiscalYearInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\FiscalYear\FiscalYearInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\FiscalYear\EloquentFiscalYear(new FiscalYear(), $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
176465
public function register()
    {
        $registrars = array(
            new CustomPostTypeRegistrar($this),
            new TaxonomyRegistrar($this)
        );

        foreach ($registrars as $registrar) {
            $registrar->register();
        }
    }