Registers taxonomy
@return void
487890
public function registerTaxonomy()
    {
        if (function_exists('get_field')) {
            $type_definitions = get_field('avabile_dynamic_taxonomies', 'option');

            if (is_array($type_definitions) && !empty($type_definitions)) {
                foreach ($type_definitions as $type_definition_key => $type_definition) {
                    register_taxonomy(
                        sanitize_title($type_definition['label']),
                        $type_definition['connected_post_types'],
                        array(
                            'label' => $type_definition['label'],
                            'rewrite' => array( 'slug' => $type_definition['slug'] ),
                            'hierarchical' => (bool) $type_definition['hierarchical'],
                            'show_admin_column' => (bool) $type_definition['show_ui'],
                            'show_ui' => (bool) $type_definition['show_ui'],
                            'public' => (bool) $type_definition['public']
                        )
                    );
                }
            }
        }
    }
258786
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/config.php', 'litecms.news');

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

        // Bind News to repository
        $this->app->bind(
            'Litecms\News\Interfaces\NewsRepositoryInterface',
            \Litecms\News\Repositories\Eloquent\NewsRepository::class
        );
        // Bind Category to repository
        $this->app->bind(
            'Litecms\News\Interfaces\CategoryRepositoryInterface',
            \Litecms\News\Repositories\Eloquent\CategoryRepository::class
        );
        // Bind Comment to repository
        $this->app->bind(
            'Litecms\News\Interfaces\CommentRepositoryInterface',
            \Litecms\News\Repositories\Eloquent\CommentRepository::class
        );
        // Bind Tag to repository
        $this->app->bind(
            'Litecms\News\Interfaces\TagRepositoryInterface',
            \Litecms\News\Repositories\Eloquent\TagRepository::class
        );

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

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

    }
619918
public function registerTaxonomy()
    {
        if (!taxonomy_exists($this->name)) {
            // create options for the Taxonomy
            $options = $this->createOptions();

            // register the Taxonomy with WordPress
            register_taxonomy($this->name, null, $options);
        }
    }
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);
            }
        }
    }
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);
		});

	}
585214
protected function registerTaxonomyField()
    {
        $this->app->bind('taxonomy.field', function ($app) {
            $viewFactory = $app['view'];
            $viewFactory->addLocation(__DIR__.'/views');

            return new TaxonomyField(
                new TaxonomyFieldRepository(),
                $viewFactory,
                $app['validator'],
                $app['action']
            );
        });
    }
1171195
public function register()
    {
        $this->registerManager();
        $this->app->singleton(
            'adminconfiguration', 
            \AvoRed\Framework\AdminConfiguration\Manager::class
        );
    }
994884
function register()
    {
        // Ensure the default options have been set.
        $customizedOptions = $this->model->getConfiguration() + array(
            'labels'              => array(),
            'supports'            => array('title', 'editor'),
            'hierarchical'        => false,
            'public'              => true,
            'show_ui'             => true,
            'show_in_menu'        => true,
            'show_in_nav_menus'   => false,
            'show_in_admin_bar'   => true,
            'menu_position'       => 5,
            'can_export'          => false,
            'has_archive'         => false,
            'exclude_from_search' => true,
            'publicly_queryable'  => true,
            'rewrite'             => array(),
            'capability_type'     => 'post',
        );

        $customizedOptions['rewrite'] += array(
            'with_front' => false,
        );


        $labelParser = new LabelParser($this->model);
        $labelParser->parse();
        $singular   = $labelParser->singular();
        $plural     = $labelParser->plural();

        $customizedOptions['labels'] += array(
            'name'                => _x($plural, 'Post Type General Name', 'strata'),
            'singular_name'       => _x($singular, 'Post Type Singular Name', 'strata'),
            'menu_name'           => __($plural, 'strata'),
            'parent_item_colon'   => __($singular. ' Item:', 'strata'),
            'all_items'           => __('All ' . $plural, 'strata'),
            'view_item'           => __('View ' . $singular. ' Item', 'strata'),
            'add_new_item'        => __('Add New', 'strata'),
            'add_new'             => __('Add New', 'strata'),
            'edit_item'           => __('Edit ' . $singular, 'strata'),
            'update_item'         => __('Update ' . $singular, 'strata'),
            'search_items'        => __('Search ' . $plural, 'strata'),
            'not_found'           => __('Not found', 'strata'),
            'not_found_in_trash'  => __('Not found in Trash', 'strata'),
        );

        return register_post_type($this->model->getWordpressKey(), $customizedOptions);
    }
111509
public function add() {
        $cmsTermTaxonomy = $this->CmsTermTaxonomy->newEntity();
        if ($this->request->is('post')) {
            $cmsTermTaxonomy = $this->CmsTermTaxonomy->patchEntity($cmsTermTaxonomy, $this->request->data);
            if ($this->CmsTermTaxonomy->save($cmsTermTaxonomy)) {
                $this->Flash->success('The cms term taxonomy has been saved.');
                return $this->redirect(['action' => 'index']);
            } else {
                $this->Flash->error('The cms term taxonomy could not be saved. Please, try again.');
            }
        }
        $cmsTerm = $this->CmsTermTaxonomy->CmsTerm->find('list', ['limit' => 200]);
        $this->set(compact('cmsTermTaxonomy', 'cmsTerm'));
        $this->set('_serialize', ['cmsTermTaxonomy']);
    }
680863
public function register_post_type() {

		if ( ! isset( $this->args['query_var'] ) || ( true === $this->args['query_var'] ) ) {
			$query_var = $this->post_type;
		} else {
			$query_var = $this->args['query_var'];
		}

		$existing = get_post_type_object( $this->post_type );
		$taxonomies = get_taxonomies( [
			'query_var' => $query_var,
		], 'objects' );

		if ( $query_var && count( $taxonomies ) ) {
			// https://core.trac.wordpress.org/ticket/35089
			foreach ( $taxonomies as $tax ) {
				if ( $tax->query_var === $query_var ) {
					trigger_error( esc_html( sprintf(
						/* translators: %s: Post type query variable name */
						__( 'Post type query var "%s" clashes with a taxonomy query var of the same name', 'extended-cpts' ),
						$query_var
					) ), E_USER_ERROR );
				}
			}
		}

		if ( empty( $existing ) ) {

			$cpt = register_post_type( $this->post_type, $this->args );

			if ( is_wp_error( $cpt ) ) {
				trigger_error( esc_html( $cpt->get_error_message() ), E_USER_ERROR );
			}
		} else {

			# This allows us to call `register_extended_post_type()` on an existing post type to add custom functionality
			# to the post type.
			$this->extend( $existing );

		}

	}
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();

        }

    }
243880
public function register_taxonomy() {

		if ( true === $this->args['query_var'] ) {
			$query_var = $this->taxonomy;
		} else {
			$query_var = $this->args['query_var'];
		}

		$post_types = get_post_types( [
			'query_var' => $query_var,
		] );

		if ( $query_var && count( $post_types ) ) {
			trigger_error( esc_html( sprintf(
				/* translators: %s: Taxonomy query variable name */
				__( 'Taxonomy query var "%s" clashes with a post type query var of the same name', 'extended-cpts' ),
				$query_var
			) ), E_USER_ERROR );
		} elseif ( in_array( $query_var, [ 'type', 'tab' ], true ) ) {
			trigger_error( esc_html( sprintf(
				/* translators: %s: Taxonomy query variable name */
				__( 'Taxonomy query var "%s" is not allowed', 'extended-cpts' ),
				$query_var
			) ), E_USER_ERROR );
		} else {
			register_taxonomy( $this->taxonomy, $this->object_type, $this->args );
		}

	}
647203
public function register()
    {
        // Store details
        $args = $this->getModel()->getArgs();
        $metaboxes = $this->getModel()->getMetaboxes();
        $slug = $this->getModel()->getSlug();

        // Register post type if not post or page
        if (!in_array($slug, $this->reserved_slugs)) {
            global $wp_rewrite;

            // Action to register
            register_post_type($slug, $args);

            // Option
            $opt = 'permalink_structure_'.$slug;

            // Get value
            $structure = Option::get($opt, '/%'.$slug.'%-%post_id%');

            // Change structure
            $wp_rewrite->add_rewrite_tag('%'.$slug.'%', '([^/]+)', $slug.'=');
            $wp_rewrite->add_permastruct($slug, $structure, false);
        }

        // Check name
        $name = isset($args['labels']['name']) ? $args['labels']['name'] : '';

        // Works on hook
        $hook = new PosttypeHook($slug, $name, $metaboxes, $this->reserved_slugs);
        $this->getModel()->setHook($hook);
    }
243843
static public function init() {
		if ( is_null( self::$instance ) ) {
			$taxonomy = Taxonomy::init();
			self::$instance = new self( $taxonomy );
			self::hooks( self::$instance );
		}
		return self::$instance;
	}
176386
public function registerTaxonomies()
    {
        if (!empty($this->taxonomies)) {
            foreach ($this->taxonomies as $taxonomy) {
                register_taxonomy_for_object_type($taxonomy, $this->name);
            }
        }
    }
848625
protected function _registerFromConfigure()
    {
        $configure = Configure::read('PostTypes.Register');

        if (!is_array($configure)) {
            $configure = [];
        }

        foreach ($configure as $key => $item) {
            $this->register($key, $item);
        }
    }
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;
        });
    }