Register the UIX object paths for autoloading

@since 1.0.0

@param array|string $arr path, or array of paths to structures to autoload
431973
public function register( $arr ) {
		// set error handler for catching file location errors
		set_error_handler( array( $this, 'silent_warning' ), E_WARNING );
		// determine how the structure works.
		foreach ( (array) $arr as $key => $value ) {
			$this->locations = array_merge_recursive( $this->locations, $this->get_files_from_folders( trailingslashit( $value ) ) );
		}

		// restore original handler
		restore_error_handler();
	}
1228150
protected function register(array $args)
    {
        array_walk($args, function (array $value, string $key) {
            \genesis_register_layout($key, $value);
        });
    }
1188087
public function registerAutoloader()
    {
        $this->app->afterResolving(DocumentManagerRegistry::class, function (ManagerRegistryInterface $registry) {
            /** @var DocumentManager $manager */
            foreach ($registry->getManagers() as $manager) {
                Autoloader::register(
                    $manager->getConfiguration()->getProxyDir(),
                    $manager->getConfiguration()->getProxyNamespace()
                );

            }
        });
    }
23272
private function autoLoadAssets()
    {
        // Add in the CDN-typed assets
        foreach(config('assetprocessor.autoload.cdn', array()) as $asset)
        {
            // Add in the asset
            self::cdn($asset, $asset);
        }

        // Add in the local assets
        foreach(config('assetprocessor.autoload.local', array()) as $asset)
        {
            // Add in the asset
            self::add($asset, $asset);
        }        
    }
325895
protected function registerAutoloader($app)
    {
        // now configure a new autoloader spl configuration
        $autoloaderApp = new Doozr_Loader_Autoloader_Spl_Config();
        $autoloaderApp
            ->_namespace($app->namespace)
            ->namespaceSeparator('_')
            ->addExtension('php')
            ->path(substr($app->path, 0, -1))
            ->description('Autoloader for App classes with namespace: "'.$app->namespace.'"')
            ->priority(0);

        Doozr_Loader_Autoloader_Spl_Facade::attach([$autoloaderApp]);
    }
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);
        });
    }
890764
function Read($arr)
	{
		foreach (get_object_vars($this) as $prop)
		{
			if (array_key_exists($prop,$arr))
			{
				$this->$prop = $arr[$prop];
			}
		}
	}
263000
final public function traverse(array &$arr)
    {
        if (!$this->isReady()) {
            throw new \RuntimeException("The traverser is not ready, no valid item callback has been set.");
        }

        return static::run($arr, $this->itemCallback, $this->resultCallback);
    }
356959
public static function register($path)
	{
		self::$_path = $path;
		self::addPath($path);

		if ($loaders = spl_autoload_functions())
			array_map('spl_autoload_unregister', $loaders);
		else
			$loaders = function_exists('__autoload') ? array('__autoload') : array();

		array_unshift($loaders, array(__CLASS__, 'load'));
		array_map('spl_autoload_register', $loaders);
	}
1372444
function register(handle) {
  if (Array.isArray(handle)) {
    handle.forEach(item => {
      utils.register(item);
    });
  } else {
    utils.register(handle);
  }
}
339286
public function register(array $aOptions = array())
    {
        $sentry = jaxon()->sentry();
        $sentry->addClassOptions($this->appConfig);
        $sentry->mergeClassOptions($aOptions);
        $sentry->register();
    }
614677
function autoload()
    {
        $pathList = $this->autoloadPathList();
        foreach ( $pathList as $path )
        {
            $autoloadFile = $path . 'eztemplateautoload.php';
            if ( file_exists( $autoloadFile ) )
            {
                unset( $eZTemplateOperatorArray );
                unset( $eZTemplateFunctionArray );
                include( $autoloadFile );
                if ( isset( $eZTemplateOperatorArray ) &&
                     is_array( $eZTemplateOperatorArray ) )
                {
                    foreach ( $eZTemplateOperatorArray as $operatorDefinition )
                    {
                        $this->registerAutoloadOperators( $operatorDefinition );
                    }
                }
                if ( isset( $eZTemplateFunctionArray ) &&
                     is_array( $eZTemplateFunctionArray ) )
                {
                    foreach ( $eZTemplateFunctionArray as $functionDefinition )
                    {
                        $this->registerAutoloadFunctions( $functionDefinition );
                    }
                }
            }
            else
            {
                eZDebug::writeWarning( "Path '$path' does not have the file 'eztemplateautoload.php' allthough it reported it had one.\n" .
                                       "Looked for file '" . $autoloadFile . "'\n" .
                                       "Check the setting [TemplateSettings]/ExtensionAutoloadPath or AutoloadPathList in your site.ini settings." );
            }
        }
    }
131712
public function setParams($arr = [])
    {
        foreach ($arr  as $key => $value) {
            $this->params[$key] = $value;
        }
    }
156200
private function registerInvocations(array $invocations)
    {
        foreach ($invocations as $invocation) {
            if ($invocation->getArgument(0)->getType() != ReflectionArgument::STRING) {
                //We can only index invocations with constant string arguments
                continue;
            }

            $string = $invocation->getArgument(0)->stringValue();
            $string = $this->prepareMessage($string);

            $this->registerMessage($this->invocationDomain($invocation), $string, false);
        }
    }
284474
public function register($prepend = false)
    {
        if (!$this->isLoaded) {
            spl_autoload_register(array($this, 'loadClass'), true, $prepend);
        }
        $this->isLoaded = true;
    }
292924
protected function registerLoaders()
    {
        // The array used in the ArrayLoader
        $this->app->bindIf('twig.templates', function () {
            return [];
        });

        $this->app->bindIf('twig.loader.array', function ($app) {
            return new ArrayLoader($app['twig.templates']);
        });

        $this->app->bindIf('twig.loader.viewfinder', function () {
            return new Twig\Loader(
                $this->app['files'],
                $this->app['view']->getFinder(),
                $this->app['twig.extension']
            );
        });

        $this->app->bindIf(
            'twig.loader',
            function () {
                return new ChainLoader([
                    $this->app['twig.loader.array'],
                    $this->app['twig.loader.viewfinder'],
                ]);
            },
            true
        );
    }
1009300
protected function registerFacadesAliases(): void
    {
        $loader = AliasLoader::getInstance();

        foreach ((array) $this->facades as $facade => $aliases) {
            foreach ((array) $aliases as $alias) {
                $loader->alias($alias, $facade);
            }
        }
    }