Initializes the Doctrine Type comments instance variable for in_array() checks.

@return void
501074
protected function initializeCommentedDoctrineTypes()
    {
        $this->doctrineTypeComments = [];

        foreach (Type::getTypesMap() as $typeName => $className) {
            $type = Type::getType($typeName);

            if (! $type->requiresSQLCommentHint($this)) {
                continue;
            }

            $this->doctrineTypeComments[] = $typeName;
        }
    }
510670
public function initialize()
    {
        if (!$this->isInitialized()) {
            $this->getOriginalNodeNames();
            $fetchDepth = $this->fetchDepth > 0 ? $this->fetchDepth + 1 : -1;
            $childNodes = $this->getNode($fetchDepth)->getNodes($this->filter);
            $this->collection = new ArrayCollection($this->getChildren($childNodes));
            $this->initialized = self::INITIALIZED_FROM_PHPCR;
        }
    }
37750
private function initTypes()
    {
        $this->types = array();

        foreach ($this->loadTypes() as $type) {
            if (!$type instanceof TableTypeInterface) {
                throw new UnexpectedTypeException($type, 'Swoopaholic\Component\Table\TableTypeInterface');
            }

            $this->types[$type->getName()] = $type;
        }
    }
116486
function (array) {
                if (!(ariaUtilsType.isObject(array) || ariaUtilsType.isArray(array))) {
                    this.$logError(this.INVALID_TYPE_OF_ARGUMENT);
                    return;
                }
                this.initialArray = array;
                this._refreshInitialArray();
            }
541631
private function init() {
		$this->home();
		$this->applyRules();
		IfTTT::runArray([
			'is_404'               => [ $this, 'notFound'],
			'is_search'            => [ $this, 'search'],
			'is_tax'               => [ $this, 'tax'],
			'is_attachment'        => [ $this, 'attachment'],
			'is_singular'          => [ $this, 'singular'],
			'is_category'          => [ $this, 'category'],
			'is_tag'               => [ $this, 'tag'],
			'is_author'            => [ $this, 'author'],
			'is_day'               => [ $this, 'day'],
			'is_month'             => [ $this, 'month'],
			'is_year'              => [ $this, 'year'],
			'is_post_type_archive' => [ $this, 'postTypeArchive']
		]);
	}
947981
private function initializeAllDoctrineTypeMappings()
    {
        $this->initializeDoctrineTypeMappings();

        foreach (Type::getTypesMap() as $typeName => $className) {
            foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) {
                $this->doctrineTypeMapping[$dbType] = $typeName;
            }
        }
    }
806891
protected function initialize(): void
    {
        if ($this->result === null) {
            $queryBuilder = $this->elasticSearchQuery->getQueryBuilder();
            $this->result = $queryBuilder->fetch();
            $this->nodes = $this->result['nodes'];
            $this->count = $queryBuilder->getTotalItems();
        }
    }
863976
private static function _initialize() 
    {
        for ($i=self::SINGULAR; $i <= self::IRREGULAR; $i++) {
            if (!array_key_exists($i, self::$_inflections)) {
                self::$_inflections[$i] = array();
            }
        }
    }
961417
protected function initAttrs()
    {
        $attrs = self::getAttrs();
        foreach ($attrs as $key => $attr) {
            if (! isset($attr['default'])) continue;
            if (! isset($this->cleanData[$key])) {
                $this->$key = $attr['default'];
            }
        }
    }
191543
public function initialize()
    {
        $this->initializeShortAliases();
        $this->initializeDefaultAliases();
        foreach ($this->schemaManager->getSchemaTables() as $table) {
            $this->loadMetadataForTable($table);
        }
        $this->initialized = true;
    }
1093529
protected function initialize()
    {
        $this->data = new stdClass();
        $this->data->ownId = null;
        $this->data->amount = new stdClass();
        $this->data->amount->currency = self::AMOUNT_CURRENCY;
        $this->data->amount->subtotals = new stdClass();
        $this->data->items = [];
        $this->data->receivers = [];
        $this->data->checkoutPreferences = new stdClass();
        $this->data->checkoutPreferences->redirectUrls = new stdClass();
        $this->data->checkoutPreferences->installments = [];
    }
1078197
public function initializeArguments()
    {
        parent::initializeArguments();
        $this->registerArgument('name', 'string', 'name of template variable to assign the result to', false, null);
        $this->registerArgument('array', 'array', 'existing array to add the new keys and values to', false, []);

        $this->registerArgument('keys', 'array', 'array of keys', false, null);
        $this->registerArgument('values', 'array', 'array of values', false, []);

        $this->registerArgument('global', 'boolean',
            'whether to make the variable available to all templates coming afterwards', false, false);
        $this->registerArgument('omitEmptyFields', 'boolean', 'omits empty fields', false, false);
    }
885182
private function initializeInternalTypes(): void
    {
        $phpToGraphQLMapping = [
            // PHP types
            'id' => Type::id(),
            'bool' => Type::boolean(),
            'int' => Type::int(),
            'float' => Type::float(),
            'string' => Type::string(),

            // Doctrine types
            'boolean' => Type::boolean(),
            'integer' => Type::int(),
            'smallint' => Type::int(),
            'bigint' => Type::int(),
            'decimal' => Type::string(),
            'text' => Type::string(),
        ];

        $this->types = $phpToGraphQLMapping;
        $this->registerInstance(new LogicalOperatorType());
        $this->registerInstance(new JoinTypeType());
        $this->registerInstance(new SortingOrderType());
    }
1049830
public static function initialize() {
		foreach ( static::$core_types as $name => $class ) {
			static::register( $name, new $class );
		}

		foreach ( static::$bindings as $name => $binding ) {
			if ( ! static::resolved( $name ) ) {
				static::fire( $name, $binding['callback'], $binding['sanitizer'] );

				static::$resolved[ $name ] = true;
			}
		}

		// Print the field type JS templates.
		if ( count( static::$instances ) > 0 ) {
			add_action( 'admin_footer', [ __CLASS__, 'print_js_templates' ], 20 );
		}
	}
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"]);
            }
        }
    }
740850
protected function init()
    {
        if (true===$this->isInited) {
            return;
        }

        $this->_cleanFilesStack();

        if (empty($this->__adapter_type)) {
            $this->_guessAdapterType();
        }

        if (!empty($this->__adapter_type)) {
            if (class_exists($this->__adapter_type)) {
                $this->__adapter = new $this->__adapter_type;
                if (!($this->__adapter instanceof AbstractCompressorAdapter)) {
                    throw new \LogicException(
                        sprintf('Compressor adapter must extend class "%s" (having object "%s")!', "Assets\AbstractCompressorAdapter", $this->__adapter_type)
                    );
                }
            } else {
                throw new \RuntimeException(
                    sprintf('Compressor adapter for type "%s" doesn\'t exist!', $this->__adapter_type)
                );
            }
        }

        $this->isInited = true;
    }
720385
private function initActionTypes()
    {
        $this->actionTypes = [];

        foreach ($this->loadActionTypes() as $type) {
            if (!$type instanceof ActionTypeInterface) {
                throw new UnexpectedTypeException($type, ActionTypeInterface::class);
            }

            $this->actionTypes[get_class($type)] = $type;
        }
    }