Register the PostType
@return void
335142
public function registerPostType()
    {
        // create options for the PostType
        $options = $this->createOptions();

        // check that the post type doesn't already exist
        if (!post_type_exists($this->name)) {
            // register the post type
            register_post_type($this->name, $options);
        }
    }
1361677
function register_taxonomies() {

        if ( is_array( $this->taxonomy_settings ) ) {

            // Foreach taxonomy registered with the post type.
            foreach ( $this->taxonomy_settings as $taxonomy_name => $options ) {

                // Register the taxonomy if it doesn't exist.
                if ( ! taxonomy_exists( $taxonomy_name ) ) {

                    // Register the taxonomy with Wordpress
                    register_taxonomy( $taxonomy_name, $this->post_type_name, $options );

                } else {

                    // If taxonomy exists, register it later with register_exisiting_taxonomies
                    $this->exisiting_taxonomies[] = $taxonomy_name;
                }
            }
        }
    }
1160903
public function register( $post_types = [] ) {
		foreach ( $post_types as $post_type => $callback ) {
			$this->post_types[ $post_type ] = [
				'callback' => $callback,
			];
		}
	}
702579
public function register()
    {
        $this->registerHtmlBuilder();

        $this->registerFormBuilder();

        $this->registerAntaresFormBuilder();

        $this->registerCustomfieldsFinder();

        $this->app->alias('html', 'Antares\Html\HtmlBuilder');
        $this->app->alias('form', 'Antares\Html\FormBuilder');
    }
105395
protected function registerDataTypeRegistry()
    {
        $this->app->singleton(Registry::class, function () {
            $registry = new Registry();
            foreach (config('metable.datatypes') as $handler) {
                $registry->addHandler(new $handler());
            }

            return $registry;
        });
        $this->app->alias(Registry::class, 'metable.datatype.registry');
    }
1158970
public function registerPageMap() {

		$this->pageMap[ CmsGlobal::TYPE_PAGE ]		= Page::class;
		$this->pageMap[ CmsGlobal::TYPE_ARTICLE ]	= Article::class;
		$this->pageMap[ CmsGlobal::TYPE_POST ]		= Post::class;
	}
412963
public function register()
    {
        $this->shareWithApp();
        $this->setPublishGroups();
        $this->registerAliases();
        $this->registerViews();
        $this->registerArtisanCommands();
    }
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']
                        )
                    );
                }
            }
        }
    }
1182529
public function registered_post_type( string $post_type, WP_Post_Type $post_type_object ) {
		if ( $post_type !== $this->post_type ) {
			return;
		}
		$struct = str_replace( "%{$this->post_type}_slug%", $this->post_slug, $post_type_object->rewrite['permastruct'] );
		$struct = str_replace( '%postname%', "%{$this->post_type}%", $struct );
		add_permastruct( $this->post_type, $struct, $post_type_object->rewrite );
	}
74496
public function register()
    {
        $this->loadRoutesFrom(__DIR__.'/routes/web.php');
        $this->loadViewsFrom(__DIR__.'/resources/views/', 'LaravelLogger');
        $this->loadMigrationsFrom(__DIR__.'/database/migrations');
        if (file_exists(config_path('laravel-logger.php'))) {
            $this->mergeConfigFrom(config_path('laravel-logger.php'), 'LaravelLogger');
        } else {
            $this->mergeConfigFrom(__DIR__.'/config/laravel-logger.php', 'LaravelLogger');
        }
        $this->registerEventListeners();
        $this->publishFiles();
    }
1229177
public function register()
    {
        register_post_type($this->slug, [
            'labels'      => $this->labels,
            'public'      => $this->public,
            'has_archive' => $this->has_archive,
            'menu_icon'   => 'dashicons-' . $this->icon,
            'supports'    => $this->supports,
            'rewrite'     => [
                'slug' => $this->rewrite->slug,
                'with_front'  => $this->rewrite->with_front
            ]
        ]);
    }
51538
public function register()
    {
        foreach ($this->postTypes as $postType) {
            $this->app['posts.types']->register($postType);
            $this->app['filters']->listen(
                'theme_' . strtolower(class_basename($postType)) . '_templates',
                function ($page_templates) use ($postType) {
                    $laraPressTemplates = [];

                    foreach ($postType::getAvailableTemplates() as $key => $template) {
                        if (is_int($key)) {
                            $key = $template;
                            $template = ucwords(str_replace('-', ' ', $template));
                        }
                        $laraPressTemplates[$key] = $template;
                    }

                    return array_merge($page_templates, $laraPressTemplates);
                }
            );
        }
    }
165843
public function register()
    {
        $this->bindGuzzle();

        $this->bindAuth();

        $this->bindHttpClient();

        $this->bindApiClient();

        $this->bindTaxonomyMapper();
    }
184614
protected function registerRequestTypes()
    {
        foreach ($this->requests as $key => $requestType) {
            $contract = is_string($key) ? $key : $this->convention->contractForRequest($requestType);
            $this->concord->registerRequest($contract, $requestType);
        }
    }
1184773
protected function registerPosttype()
    {
        if (! $this->isRegistered()) {
            $parameters = array_merge(
                ['labels' => $this->model->getLabels()],
                $this->model->getArguments()
            );

            return register_post_type($this->model->getSlug(), $parameters);
        }

        throw new PosttypeException("Posttype [{$this->model->getSlug()}] already exsist.");
    }
845378
public function mf_register_post_types(){
    global $mf_pt_register,$mf_pt_unique;

    $post_types = $this->_get_post_types();
    
    foreach($post_types as $p){
      $p = unserialize($p['arguments']);

      $name = $p['core']['type'];
      $option = $p['option'];

      $option['show_in_menu'] = ($option['show_in_menu']) ? true : false;
      $option['query_var'] = ($option['query_var']) ? true : false;
      $option['exclude_from_search'] = ($option['exclude_from_search']) ? true : false;
      $option['labels'] = $p['label'];
      $option['with_front'] = (isset($option['with_front'])) ? $option['with_front'] : true;


      if( isset($p['support']) ){
        foreach($p['support'] as $k => $v){
          $option['supports'][] = $k;
        }
      }

      //always add support for the editor
      $option['supports'][] = 'editor';
      $option['supports'] = array_unique($option['supports']);

      if( isset($p['taxonomy']) ){
        foreach($p['taxonomy'] as $k => $v){
          //register_taxonomy_for_object_type($k, $name);
          $option['taxonomies'][] = $k;
        }
      }
			if(isset($option['has_archive']) && $option['has_archive'] && isset($option['has_archive_slug']) && $option['has_archive_slug'])	
				$option['has_archive'] = $option['has_archive_slug'];
			
			
      if($option['rewrite'] && $option['rewrite_slug'])
        $option['rewrite'] = array( 'slug' => $option['rewrite_slug'],'with_front' => $option['with_front']);

      unset($option['rewrite_slug']);
      unset($option['with_front']);
      array_push($mf_pt_register,$name);

      if($option['menu_position']){
        $option['menu_position'] = (int)$option['menu_position'];
      }

      //check Capability type
      trim($option['capability_type']);
      if(empty($option['capability_type'])){
        $option['capability_type'] = 'post';
      }elseif( !in_array($option['capability_type'],array('post','page')) ){
        $option['capabilities'] = $this->_get_cap($option['capability_type']);
      }
      
      //classic pin image for the menu
      if ( isset($option['menu_icon']) && empty($option['menu_icon']) )  {
        unset($option['menu_icon']);
      }
       
      


      //description
      $option['description'] = $p['core']['description'];
      register_post_type($name,$option);

      //add unique post type
      if (isset($p['core']['quantity']) && $p['core']['quantity'] == 1) {
        array_push($mf_pt_unique, "edit.php?post_type=".$name);
      }
     
     
    }
  
  }
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 );
		}

	}