Deinitializes the writer

@return void
965898
public function deinitWriter()
    {
        if ( is_null( $this->dom ) )
        {
            throw new ezcTranslationWriterNotInitializedException();
        }
        $filename = $this->buildTranslationFileName( $this->writeLocale );
        $this->dom->save( $filename );
    }
196588
public function doFinalInitialization()
    {
        // Heavy indexing must wait until after all columns composing
        // a table's primary key have been parsed.
        if ($this->heavyIndexing) {
            $this->doHeavyIndexing();
        }

        // if idMethod is "native" and in fact there are no autoIncrement
        // columns in the table, then change it to "none"
        $anyAutoInc = false;
        foreach ($this->columns as $column) {
            if ($column->isAutoIncrement()) {
                $anyAutoInc = true;
            }
        }
        if (IdMethod::NATIVE === $this->getIdMethod() && !$anyAutoInc) {
            $this->setIdMethod(IdMethod::NO_ID_METHOD);
        }
    }
633961
public function init()
    {
        $this->idAttribute = '_id';
        $this->idAttributeType = static::$idTypeAutoIncrement;
        if ($this->skipInit) {
            return;
        }
        $this->initEntityEvents();
        parent::init();
    }
1174723
public void initialize() {
        try {
            writeLock.lock();
            if (!isInitialized()) {
                super.initialize();
                setInitialized(true);
                this.initCalled = true;
            }
        } finally {
            // downgrade to readlock before releasing just in case
            readLock.lock();
            writeLock.unlock();
            readLock.unlock();
        }
    }
139432
public function initialize()
    {

        $this->id = null;
        $this->recordId = null;
        $this->toolProxy = null;
        $this->created = null;
        $this->updated = null;

    }
893807
public function initialize() : void
    {
        foreach (glob("{$this->cssDir}/*.css") as $file) {
            $filename = basename($file);
            $url = "{$this->cssUrl}/$filename";
            $content = file_get_contents($file);
            $comment = strstr($content, "*/", true);
            $comment = preg_replace(["#\/\*!#", "#\*#"], "", $comment);
            $comment = preg_replace("#@#", "<br>@", $comment);
            $first = strpos($comment, ".");
            $short = substr($comment, 0, $first + 1);
            $long = substr($comment, $first + 1);
            $this->styles[$url] = [
                "shortDescription" => $short,
                "longDescription" => $long,
            ];
        }

        foreach ($this->styles as $key => $value) {
            $isMinified = strstr($key, ".min.css", true);
            if ($isMinified) {
                unset($this->styles["$isMinified.css"]);
            }
        }
    }
930487
protected function _init() {
		$mobileOverwrite = $this->Controller->getRequest()->getQuery('mobile');

		if ($mobileOverwrite !== null) {
			if ($mobileOverwrite === '-1') {
				$this->Controller->getRequest()->getSession()->delete('User.mobile');
			} else {
				$wantsMobile = (bool)$mobileOverwrite;
				$this->Controller->getRequest()->getSession()->write('User.mobile', (int)$wantsMobile);
			}
		}
		$this->isMobile();

		if (!$this->_config['auto']) {
			return;
		}
		$this->setMobile();
	}
849571
public function initialize()
    {
        if ( ! isset($this->authenticator)) {
            throw new \RuntimeException('Aegis is missing an authentication authenticator.');
        }

        if ( ! isset($this->storage)) {
            throw new \RuntimeException('Aegis is missing a persistent storage engine.');
        }

        // Set inital token to be anonymous until proven otherwise
        $this->setToken(new AnonymousToken());

        // Attempt to read token from persistent storage
        $token = $this->storage->read();

        // Re-authenticate stored token
        if ($token instanceof TokenInterface) {
            $result = $this->authenticate($token);
        }

        $this->initialized = true;

        return $this;
    }
1181852
private function initialize()
    {
        if ($this->initialized) {
            return;
        }

        if ($this->session->isStarted() && $this->session->get('stack') !== null) {
            $paths = $this->session->get('stack');
            $this->files = $this->hydrateList($paths);
        } else {
            $paths = $this->users->getCurrentUser()['stack'];
            $this->files = $this->hydrateList($paths);
            $this->session->set('stack', $this->persistableList());
        }

        $this->initialized = true;
    }
658156
public function initialize() {
    $this->uuidGenerator = new Php();
    $template_dir = $this->getConfigValue('blt.root') . '/scripts/config-split/templates';
    $loader = new \Twig_Loader_Filesystem($template_dir);
    $this->twig = new \Twig_Environment($loader);
    $docroot = $this->getConfigValue('docroot');
    $this->configSyncDir = $docroot . '/' . $this->getConfigValue('cm.core.dirs.sync.path');
    $this->configSplitDir = $docroot . '/' . $this->getConfigValue('cm.core.path') . '/envs';
  }
1201250
protected function init() {
        if (isset($this->stores)) {
            // Do not bother checking readers and writers here
            // because everything is init here.
            return;
        }
        $this->stores = array();
        $this->readers = array();
        $this->writers = array();

        // Register shutdown handler - this may be useful for buffering, file handle closing, etc.
        \core_shutdown_manager::register_function(array($this, 'dispose'));

        $plugins = get_config('tool_log', 'enabled_stores');
        if (empty($plugins)) {
            return;
        }

        $plugins = explode(',', $plugins);
        foreach ($plugins as $plugin) {
            $classname = "\\$plugin\\log\\store";
            if (class_exists($classname)) {
                $store = new $classname($this);
                $this->stores[$plugin] = $store;
                if ($store instanceof \tool_log\log\writer) {
                    $this->writers[$plugin] = $store;
                }
                if ($store instanceof \core\log\reader) {
                    $this->readers[$plugin] = $store;
                }
            }
        }
    }
739958
public function reset()
    { 
        $this->setPosition(0);
        $this->setOnWriteDataMode(false);
        $this->setDataBuffer(null);
        $this->setResource(null);
    }
1355294
public static function init()
    {
        foreach (self::$_registeredThemes as $registeredTheme) {
            $theme = self::_initializeTheme($registeredTheme);
            self::$_themes[$theme->id()] = $theme;
        }

        self::$_initialized = true;
    }
606327
protected function initialize()
    {
        $this->data = new stdClass();
        $this->data->transferInstrument = new stdClass();
        $this->data->transferInstrument->bankAccount = new stdClass();
        $this->data->transferInstrument->bankAccount->holder = new stdClass();
        $this->data->transferInstrument->bankAccount->holder->taxDocument = new stdClass();
    }
443877
private function initialize()
    {
        $this->entity = '';
        $this->source = '';
        $this->mode = self::RSMODE_NOTCONNECTED;
        $this->result = null;
        $this->originalValues = null;
        $this->datafields = [];
        $this->values = [];
        $this->idFields = [];
    }
227866
private function onWritable()
    {
        $bytesWritten = @\fwrite($this->socket, $this->writeBuffer);

        if ($bytesWritten === false) {
            $this->close();
            return;
        }

        if ($bytesWritten === 0) {
            return;
        }

        $this->timeoutCache->renew($this->id);

        if ($bytesWritten !== \strlen($this->writeBuffer)) {
            $this->writeBuffer = \substr($this->writeBuffer, $bytesWritten);
            return;
        }

        $this->writeBuffer = "";

        Loop::disable($this->writeWatcher);
        $deferred = $this->writeDeferred;
        $this->writeDeferred = null;
        $deferred->resolve();
    }
588092
private function initPersist()
    {
        $this->debug->groupCollapsed(__METHOD__);
        $this->persist = new Persist($this->cfg['name'], array(
            'persist'           => $this->cfg['persist'],
            'trashCollectable'  => $this->cfg['trashCollectable'],
            'userKey' => $this->cfg['verifyKey']
                ? ( isset($_REQUEST['_key_']) ? $_REQUEST['_key_'] : null )
                : false,
        ));
        if (!$this->persist->pageCount()) {
            $this->debug->info('persist just created... add first page');
            $firstPageName = \key($this->cfg['pages']);
            $this->persist->appendPages(array($firstPageName));
        }
        $this->debug->groupEnd();
    }