Initializes this workspace.

If this workspace is brand new, a root node is created automatically.

@param integer $initializationCause
@return void
554898
public function initializeObject($initializationCause)
    {
        if ($initializationCause === ObjectManagerInterface::INITIALIZATIONCAUSE_CREATED) {
            $this->rootNodeData = new NodeData('/', $this);
            $this->nodeDataRepository->add($this->rootNodeData);

            if ($this->owner instanceof UserInterface) {
                $this->setOwner($this->owner);
            }
        }
    }
1327847
public function init()
    {
        if (count($this->buckets))
        {
            foreach ($this->buckets as $alias => $bucket) 
            {
                $this->_buckets[$alias] = new BucketFileSystem(
                    $bucket['basePath'],
                    $bucket['baseUrl'],
                    isset($bucket['filePermission']) ? $bucket['filePermission'] : 0777
                );
            }
        }
    }
32884
public function init()
    {
        parent::init();
        if (!$this->site) {
            $this->site = 'hiam.hipanel.com';
        }
        if (strpos($this->site, '://') === false) {
            $this->site = 'https://' . $this->site;
        }
        $defaults = [
            'authUrl' => 'oauth/authorize',
            'tokenUrl' => 'oauth/token',
            'apiBaseUrl' => 'api',
        ];
        foreach ($defaults as $k => $v) {
            if (!$this->{$k}) {
                $this->{$k} = $this->buildUrl($v);
            }
        }
    }
871005
public function init()
    {
        $this->_callee = $this->project->createTask("phing");
        $this->_callee->setOwningTarget($this->getOwningTarget());
        $this->_callee->setTaskName($this->getTaskName());
        $this->_callee->setHaltOnFailure(true);
        $this->_callee->setLocation($this->getLocation());
        $this->_callee->init();

    }
57978
protected function initialize()
    {
        $this->container = new Container();

        $containerProvider = new ContainerProvider($this->disabledMethods, $this->disabledFormats);
        $this->container->register($containerProvider);

        $this->initialized = false;
    }
1338018
public function init()
    {
        if ($this->isEnabled()) {
            $this->asteriskclient = Pool::getInstance($this->config->asteriskclientname->value);
        }
    }
328211
public function initialize()
    {
        if (true === $this->hasBeenInitialized) {
            return;
        }

        $this->hasBeenInitialized = true;

        foreach ($this->service as $service) {
            list($serviceClassName, $serviceOptions) = $this->manageServiceData($service);

            $this->serviceInstances[$serviceClassName] = $this->getServiceInstance($serviceClassName, $serviceOptions);
        }
    }
27679
public static void initialize()
    {
        if (InfinispanCache.get().exists(Role.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Role>getCache(Role.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Role>getCache(Role.UUIDCACHE).addListener(new CacheLogListener(Role.LOG));
        }
        if (InfinispanCache.get().exists(Role.IDCACHE)) {
            InfinispanCache.get().<Long, Role>getCache(Role.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Role>getCache(Role.IDCACHE).addListener(new CacheLogListener(Role.LOG));
        }
        if (InfinispanCache.get().exists(Role.NAMECACHE)) {
            InfinispanCache.get().<String, Role>getCache(Role.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Role>getCache(Role.NAMECACHE).addListener(new CacheLogListener(Role.LOG));
        }
    }
851100
private void initializeIfNeeded() throws BackendInitializationException,
            BackendNewInstanceException {
        if (isClosed()) {
            throw new IllegalStateException("Knowledge source already closed!");
        }
        if (this.inDataSourceGetter == null) {
            this.inDataSourceGetter
                    = new SubtreePropositionDefinitionGetterRegular(this, true);
        }
        if (this.collectSubtreeGetter == null) {
            this.collectSubtreeGetter
                    = new SubtreePropositionDefinitionGetterRegular(this, false);
        }
    }
541969
public function init($environment = 'production'): void
    {
        $this->environment = $environment;

        try {
            // initial default helper path
            $this->addHelperPath(__DIR__ . '/Helper/');

            // init Config
            $this->initConfig();

            // first log message
            Logger::info('app:init');

            // init Session, start inside class (if needed)
            Session::getInstance();

            // init Messages
            Messages::getInstance();

            // init Request
            $this->initRequest();

            // init Response
            $this->initResponse();

            // init Translator
            $this->initTranslator();

            // init Router
            $this->initRouter();
        } catch (\Exception $e) {
            throw new ApplicationException("Application can't be loaded: " . $e->getMessage());
        }
    }
554933
public function init()
    {
        if ($this->getCache() === null) {
            $options = $this->getOptions();
            $this->setCache(Cache\StorageFactory::factory($options['cache']));
        }

        $this->isInit = true;
    }
971085
public function initialize() {
		Configure::write('Cache.disable', true);
		parent::initialize();

		if (!Configure::check('CakeInstaller')) {
			$this->ConfigInstaller->initConfig();
		}

		foreach ($this->_defaultConfigs['default'] as $paramName => &$paramOptions) {
			if (isset($paramOptions['label'])) {
				$paramOptions['label'] = __d('cake_installer_label', $paramOptions['label']);
			}
		}
	}
463580
public void init(boolean useDirect, int outSize, int inSize, int cacheSize) {
        super.init(useDirect, outSize, inSize, cacheSize);
    }
416716
public function initializeDca(): void
    {
        /** @var Input $input */
        $input = $this->framework->getAdapter(Input::class);

        if ($input->get('act') !== 'edit') {
            return;
        }

        $model = $this->repository->findByPk(Input::get('id'));
        if (!$model || $model->type !== 'bs_grid_gallery') {
            return;
        }

        $GLOBALS['TL_CSS'][] = 'bundles/contaobootstrapgrid/css/backend.css';

        $GLOBALS['TL_DCA']['tl_content']['fields']['galleryTpl']['options_callback'] = [
            'contao_bootstrap.grid.listeners.dca.content',
            'getGalleryTemplates',
        ];
    }
1234728
public void initialise(Identifier rootId, boolean enableCache)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(cclass, "initialise", new Object[] {rootId, new Boolean(enableCache)});

    switch (rootId.getType()) {
      case Selector.UNKNOWN :
      case Selector.OBJECT :
        matchTree = new EqualityMatcher(rootId);
        break;
      case Selector.STRING :
      case Selector.TOPIC :
        matchTree = new StringMatcher(rootId);
        break;
      case Selector.BOOLEAN :
        matchTree = new BooleanMatcher(rootId);
        break;
      default:
        matchTree = new NumericMatcher(rootId);
        break;
    }
    if (enableCache) {
      this.rootId = rootId;
      matchCache = new MatchCache(MATCH_CACHE_INITIAL_CAPACITY);
      matchCache.setRehashFilter(this);
      ((EqualityMatcher) matchTree).setCacheing(true);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(cclass, "MatchSpaceImpl", this);
  }
1316517
public function initialise() {
        if ($this->initialised || during_initial_install()) {
            return false;
        }
        $this->context = $this->page->context;
        $this->load_administration_settings();

        // Check if local plugins is adding node to site admin.
        $this->load_local_plugin_settings();

        $this->initialised = true;
    }
794581
public function actionInit() : void
    {
        $this->initSURole();
        $config = $this->loadConfig();
        $this->applyConfig($config);
        $this->applyAssignConfig($config);
        $this->addAssignmentsToSu();
        $this->log(true);
    }