Register the classes recursively.
553955
private void parseSubHierarchy(final Node parent, final AvroNode n) {
    final Node parsed;
    if (n.getPackageNode() != null) {
      parsed = new PackageNodeImpl(parent, getString(n.getName()), getString(n.getFullName()));
    } else if (n.getNamedParameterNode() != null) {
      final AvroNamedParameterNode np = n.getNamedParameterNode();


      parsed = new NamedParameterNodeImpl<>(parent, getString(n.getName()), getString(n.getFullName()),
              getString(np.getFullArgClassName()), getString(np.getSimpleArgClassName()), np.getIsSet(), np.getIsList(),
              getString(np.getDocumentation()), getString(np.getShortName()), getStringArray(np.getInstanceDefault()));
    } else if (n.getClassNode() != null) {
      final AvroClassNode cn = n.getClassNode();
      final List<ConstructorDef<?>> injectableConstructors = new ArrayList<>();
      final List<ConstructorDef<?>> allConstructors = new ArrayList<>();

      for (final AvroConstructorDef injectable : cn.getInjectableConstructors()) {
        final ConstructorDef<?> def = parseConstructorDef(injectable, true);
        injectableConstructors.add(def);
        allConstructors.add(def);
      }
      for (final AvroConstructorDef other : cn.getOtherConstructors()) {
        final ConstructorDef<?> def = parseConstructorDef(other, false);
        allConstructors.add(def);
      }
      @SuppressWarnings("unchecked")
      final ConstructorDef<Object>[] dummy = new ConstructorDef[0];
      parsed = new ClassNodeImpl<>(parent, getString(n.getName()), getString(n.getFullName()), cn.getIsUnit(),
              cn.getIsInjectionCandidate(), cn.getIsExternalConstructor(), injectableConstructors.toArray(dummy),
              allConstructors.toArray(dummy), getString(cn.getDefaultImplementation()));
    } else {
      throw new IllegalStateException("Bad avro node: got abstract node" + n);
    }

    for (final AvroNode child : n.getChildren()) {
      parseSubHierarchy(parsed, child);
    }
  }
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);
            }
        }
    }
1086427
protected function registerClassAliases(): void
	{
		$aliases = $this->config->get('application.class_aliases');

		if(!empty($aliases))
		{
			$aliasLoader = new AliasLoader($aliases);

			spl_autoload_register([$aliasLoader, 'load']);
		}
	}
785653
private void registerExternalLoaders() throws MojoExecutionException {
        if (archiveLoaders != null) {
            for (String entry : archiveLoaders) {
                try {
                    SourceLoader loader = (SourceLoader) Class.forName(entry).newInstance();
                    registerLoader(loader);
                } catch (Exception e) {
                    throw new MojoExecutionException("Error registering archive loader for class: " + entry, e);
                }
            }
        }
    }
505631
public function registerSubRoutes(array $classes)
    {
        foreach ($classes as $key => $class) {
            if (is_array($class)) {
                if ($this->usableClass($key)) {
                    $this->registerAdminRoutes($key);
                }

                $this->registerSubRoutes($class);
                continue;
            }
            $this->registerAdminRoutes($class);
        }
    }
43387
private void registerOperations() {
    Class<?> type = getClass();
    for (Method method : type.getMethods()) {
      if (isOperationMethod(method)) {
        registerMethod(method);
      }
    }
  }
270162
public function register()
    {
        $steps = [
            BootKernel::class,
            ReadCache::class,
            Before::class,
            Clear::class,
            LoadContentTypes::class,
            LoadContentRenderers::class,
            LoadContentGenerators::class,
            LoadSourceFiles::class,
            Json::class,
            ParseContentTypes::class,
            Compile::class,
            WriteFiles::class,
            WriteCache::class,
            Copy::class,
            Clean::class,
            After::class,
        ];

        $this->getContainer()->add('Compile.Steps', $steps);
    }
796189
private function registerControllers()
    {
        $this->_controller = new Controller();
        $this->_controller->load($this->_router,
        $this->_config->get('basepath'));
    }
1329954
public function loadRegistries()
    {
        $registries = $this->registryFactory->getDefaultRegistries();

        foreach ($registries as $registry) {
            $this->addRegistry($registry);
        }
    }
412788
def register(root_class, klass, *identifiers)
      identifiers.map(&:to_sym).each do |identifier|
        @classes_to_identifiers[root_class][klass] ||= []

        @identifiers_to_classes[root_class][identifier] = klass
        @classes_to_identifiers[root_class][klass] << identifier
      end
    end
475962
protected function registerSingletons()
    {
        foreach ($this->singletons as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->singleton($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->singleton($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
217341
public function registerComponents()
    {
        // Check objects
        if (empty($this->paths)) {
            return;
        }

        // Work on file paths
        foreach ($this->paths as $action => $actionPaths) {
            // Work on paths
            $actionPaths = !is_array($actionPaths) ? [$actionPaths] : $actionPaths;

            // Work on file name
            $filepath = OL_ZEUS_CACHE.$this->classname.'-'.$action.'-components.php';

            // Check cache file
            if (!file_exists($filepath)) {
                // Store all in cache file
                ClassMapGenerator::dump($actionPaths, $filepath);
            }

            $classmap = include_once $filepath;

            // Instanciate new ClassLoader to load and register components
            $loader = new MapClassLoader($classmap);
            $loader->register();

            // Get current hook
            $current = current_filter();
            $function = in_array($action, ['widgets_init']) ? 'registerWidgets' : 'registerObjects';

            // Register post type
            if ($action === $current) {
                // Already inside an `init` action
                $this->$function($classmap);
            } else {
                // Outside an `init` action
                add_action($action, function () use ($classmap, $function) {
                    $this->$function($classmap);
                });
            }
        }
    }
882763
protected function registerClasses()
    {
        $campaignchainBundlesContent = file_get_contents($this->configFiles['bundles']);
        $symfonyBundlesContent = file_get_contents($this->configFiles['kernel_symfony']);

        $hasNewBundles = false;

        $classes = $this->kernelConfig->getClasses();

        if (!count($classes)) {
            return;
        }

        foreach ($classes as $class) {
            // Check if the bundle is already registered in the kernel.
            if (
                strpos($campaignchainBundlesContent, $class) === false &&
                strpos($symfonyBundlesContent, $class) === false
            ) {
                $hasNewBundles = true;

                // Add the bundle class path to the CampaignChain bundles registry file.
                $campaignchainContentBundle = "\$bundles[] = new ".$class."();";

                $campaignchainBundlesContent .= "\xA".$campaignchainContentBundle;
            }
        }

        if (!$hasNewBundles) {
            return;
        }

        $fs = new Filesystem();
        $fs->dumpFile($this->configFiles['bundles'], $campaignchainBundlesContent);

    }
997241
private void addClasses(Class<?>[] classes, HashSet<Class<?>> result){
		
		if(isNull(classes) || classes.length==0)	
			Error.globalClassesAbsent(configuredClass);
		
		for (Class<?> classe : classes)	result.add(classe);
	}
632655
protected function registerClassAliases()
    {
        $aliases = __config()->class_aliases;
        if (!empty($aliases)) {
            $aliasLoader = new AliasLoader($aliases);
            spl_autoload_register([$aliasLoader, 'load']);
        }
    }
513574
def register_classes():
    
    Gtlink_select.register_class()
    Gtlink_bin.register_class()
    Gtlink_expcube2.register_class()
    Gtlink_scrmaps.register_class()
    Gtlink_mktime.register_class()
    Gtlink_ltcube.register_class()
    Link_FermipyCoadd.register_class()
    Link_FermipyGatherSrcmaps.register_class()
    Link_FermipyVstack.register_class()
    Link_FermipyHealview.register_class()
    Gtexpcube2_SG.register_class()
    Gtltsum_SG.register_class()
    SumRings_SG.register_class()
    Vstack_SG.register_class()
    GatherSrcmaps_SG.register_class()
    Healview_SG.register_class()
223697
public function register()
    {
        if ($this->model->hasTaxonomies()) {
            foreach ($this->model->getTaxonomies() as $taxonomy) {
                $this->registerTaxonomy($taxonomy);

                if ($this->shouldAddRoutes($taxonomy)) {
                    $this->addResourceRoute($taxonomy);
                }
            }
        }
    }