initialise

@return  void
@throws \ReflectionException
@throws \Windwalker\DI\Exception\DependencyResolutionException
168501
public function boot()
    {
        if ($this->booted) {
            return;
        }

        if (!$this->name) {
            throw new \LogicException('Package: ' . get_class($this) . ' name property should not be empty.');
        }

        $this->getConfig();

        $this->registerProviders($this->getContainer());

        $this->registerListeners($this->getDispatcher());

        $this->registerMiddlewares();

        $this->booted = true;
    }
383600
protected function initialize()
    {
        if ($this->isInitialized) {
            return;
        }
        if (!$this->dbAdapter instanceof Adapter) {
            throw new \Exception('No db adapter present');
        }
        if (!$this->hydrator instanceof HydratorInterface) {
            $this->hydrator = new ClassMethods;
        }
        if (!is_object($this->entityPrototype)) {
            throw new \Exception('No entity prototype set');
        }

        $this->isInitialized = true;
    }
191543
public function initialize()
    {
        $this->initializeShortAliases();
        $this->initializeDefaultAliases();
        foreach ($this->schemaManager->getSchemaTables() as $table) {
            $this->loadMetadataForTable($table);
        }
        $this->initialized = true;
    }
1029358
public function init()
    {
        $this->buildStore = Store\Factory::getStore('Build');
        $this->projectStore = Store\Factory::getStore('Project');
        $this->buildService = new BuildService($this->buildStore);
    }
1020493
public function init()
    {
        $enumRefl = new ReflectionClass(Enum::class);
        $enumPropsRefl = $enumRefl->getProperties(ReflectionProperty::IS_STATIC);
        foreach ($enumPropsRefl as $enumPropRefl) {
            $enumPropRefl->setAccessible(true);
            $this->enumPropsRefl[$enumPropRefl->getName()] = $enumPropRefl;
        }

        $this->names       = Enum66::getNames();
        $this->values      = Enum66::getValues();
        $this->ordinals    = Enum66::getOrdinals();
        $this->enumerators = Enum66::getEnumerators();
    }
1258607
public function initialize()
    {
        // attributes
        $this->setName('dealer_shedules_version');
        $this->setPhpName('DealerShedulesVersion');
        $this->setClassName('\\Dealer\\Model\\DealerShedulesVersion');
        $this->setPackage('Dealer.Model');
        $this->setUseIdGenerator(false);
        // columns
        $this->addForeignPrimaryKey('ID', 'Id', 'INTEGER' , 'dealer_shedules', 'ID', true, null, null);
        $this->addColumn('DEALER_ID', 'DealerId', 'INTEGER', true, null, null);
        $this->addColumn('DAY', 'Day', 'INTEGER', false, null, null);
        $this->addColumn('BEGIN', 'Begin', 'TIME', false, null, null);
        $this->addColumn('END', 'End', 'TIME', false, null, null);
        $this->addColumn('CLOSED', 'Closed', 'BOOLEAN', false, 1, false);
        $this->addColumn('PERIOD_BEGIN', 'PeriodBegin', 'DATE', false, null, null);
        $this->addColumn('PERIOD_END', 'PeriodEnd', 'DATE', false, null, null);
        $this->addColumn('CREATED_AT', 'CreatedAt', 'TIMESTAMP', false, null, null);
        $this->addColumn('UPDATED_AT', 'UpdatedAt', 'TIMESTAMP', false, null, null);
        $this->addPrimaryKey('VERSION', 'Version', 'INTEGER', true, null, 0);
        $this->addColumn('VERSION_CREATED_AT', 'VersionCreatedAt', 'TIMESTAMP', false, null, null);
        $this->addColumn('VERSION_CREATED_BY', 'VersionCreatedBy', 'VARCHAR', false, 100, null);
        $this->addColumn('DEALER_ID_VERSION', 'DealerIdVersion', 'INTEGER', false, null, 0);
    }
648809
public static function init()
    {
        /*
         * Push the Services into the Dependency Injector.
         */
        call_user_func(function() {
            if (file_exists(self::$basePath . '/.manifest/plugins/services.php')) {
                /** @noinspection PhpIncludeInspection */
                include self::$basePath . '/.manifest/plugins/services.php';
            }
            /** @noinspection PhpIncludeInspection */
            require self::$basePath . '/boot/services.php';
        });

        /*
         * Bootstrap the framework.
         */
        call_user_func(function() {
            /** @noinspection PhpIncludeInspection */
            require self::$basePath . '/boot/bootstrap.php';
            if (file_exists(self::$basePath . '/.manifest/plugins/bootstrap.php')) {
                /** @noinspection PhpIncludeInspection */
                include self::$basePath . '/.manifest/plugins/bootstrap.php';
            }
        });
    }
57978
protected function initialize()
    {
        $this->container = new Container();

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

        $this->initialized = false;
    }
1025164
protected function initialize()
    {
        $actionResolverMiddleware = $this->getActionResolverMiddleware(
            $this->actionResolvers,
            $this->routingResultAttribute,
            self::$actionAttribute
        );

        $actionExecutorMiddleware = $this->getActionExecutorMiddleware(
            self::$actionAttribute,
            self::$payloadAttribute
        );

        $responderResolverMiddleware = $this->getResponderResolverMiddleware(
            $this->responderResolvers,
            self::$payloadAttribute,
            self::$responderAttribute
        );

        $responderExecutorMiddleware = $this->getResponderExecutorMiddleware(
            self::$responderAttribute,
            self::$payloadAttribute
        );

        $this->pipeEach($this->beforeActionResolverMiddlewares);
        $this->pipe($actionResolverMiddleware);
        $this->pipeEach($this->beforeActionExecutorMiddlewares);
        $this->pipe($actionExecutorMiddleware);
        $this->pipeEach($this->beforeResponderResolverMiddlewares);
        $this->pipe($responderResolverMiddleware);
        $this->pipeEach($this->beforeResponderExecutorMiddlewares);
        $this->pipe($responderExecutorMiddleware);
    }
830990
public function init()
    {
        if (
            !$this->serviceContainer->isRegistered(ServiceContainer::SERVICE_LOGGER)
            || !($this->getLogger() instanceof LoggerInterface)
        ) {
            $this->setService(ServiceContainer::SERVICE_LOGGER, new NullLogger());
        }
        $this->getControllerDispatcher()->setLogger($this->getLogger());
    }
1369043
protected function init()
    {
        $this->namespaces  = array();
        $this->currentPath = '/';
        $this->pathData    = array();
        $this->parse       = FALSE;
    }
377125
public function initialize()
    {
        //The global dispatcher

        //state the application is initialized;
        //register aliases as class mocks such that static calls on mock map to instance calls;
        $this->createAliasMock(
            array_merge(
                $this->aliases, [
                    "route" => 'Budkit\Routing\Router', //this such that we can call Route::add to add router;
                    'controller' => 'Budkit\Routing\Controller',
                    'view' => 'Budkit\View\Display'
                ]
            )
        );

        //Trigger the app initialise event;
        $this->observer->trigger(new Event("app.init", $this));
    }
1339775
protected void initialise()
        throws InstallationException
    {

        if (!this.initialised) {
            this.initialised = true;
            this.cache.clear();
            AppDependency.initialise();
            for (final FileType fileType : FileType.values()) {

                if (fileType == FileType.XML) {
                    for (final InstallFile file : this.files) {
                        if (file.getType() == fileType) {
                            final SaxHandler handler = new SaxHandler();
                            try {
                                final IUpdate elem = handler.parse(file);
                                final List<IUpdate> list;
                                if (this.cache.containsKey(elem.getIdentifier())) {
                                    list = this.cache.get(elem.getIdentifier());
                                } else {
                                    list = new ArrayList<>();
                                    this.cache.put(elem.getIdentifier(), list);
                                }
                                list.add(handler.getUpdate());
                            } catch (final SAXException e) {
                                throw new InstallationException("initialise()", e);
                            } catch (final IOException e) {
                                throw new InstallationException("initialise()", e);
                            }
                        }
                    }
                } else {
                    for (final Class<? extends IUpdate> updateClass : fileType.getClazzes()) {
                        Method method = null;
                        try {
                            method = updateClass.getMethod("readFile", InstallFile.class);
                        } catch (final SecurityException e) {
                            throw new InstallationException("initialise()", e);
                        } catch (final NoSuchMethodException e) {
                            throw new InstallationException("initialise()", e);
                        }
                        for (final InstallFile file : this.files) {
                            if (file.getType() == fileType) {
                                Object obj = null;
                                try {
                                    obj = method.invoke(null, file);
                                } catch (final IllegalArgumentException e) {
                                    throw new InstallationException("initialise()", e);
                                } catch (final IllegalAccessException e) {
                                    throw new InstallationException("initialise()", e);
                                } catch (final InvocationTargetException e) {
                                    throw new InstallationException("initialise()", e);
                                }
                                if (obj != null && obj instanceof IUpdate) {
                                    final IUpdate iUpdate = (IUpdate) obj;
                                    final List<IUpdate> list;
                                    if (this.cache.containsKey(iUpdate.getIdentifier())) {
                                        list = this.cache.get(iUpdate.getIdentifier());
                                    } else {
                                        list = new ArrayList<>();
                                        this.cache.put(iUpdate.getIdentifier(), list);
                                    }
                                    list.add(iUpdate);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
714163
public function initialize()
    {
        $userMethods = $this->getCustomMethods();

        // Parse EntityMap for method based relationship
        if (count($userMethods) > 0) {
            $this->relationships = $this->parseMethodsForRelationship($userMethods);
        }

        // Parse EntityMap for dynamic relationships
        if (count($this->dynamicRelationships) > 0) {
            $this->relationships = $this->relationships + $this->getDynamicRelationships();
        }
    }
400533
public function init()
    {
        foreach (self::$registered as $path => $module) {
            $path = trailingslashit($path);
            $source = $path . $module . '.php';
            $namespace = \Modularity\Helper\File::getNamespace($source);

            if (!$namespace) {
                continue;
            }

            require_once $source;
            $class = $namespace . '\\' . $module;
            $class = new $class();

            $this->register($class, $path);
        }

        do_action('Modularity/Init', $this);
    }
625322
protected function initialize()
    {
        if ($this->initialized === true) {
            return;
        }
        $this->initialized = true;
        $this->buildFullConfiguration();
        $this->applyPostprocessing();
    }
1318438
protected function init()
    {
        if (null === $this->items) {
            list($constraints, $sorting, $joins) = $this->translate($this->filter, $this->sorting);

            if (empty($constraints)) {
                $constraints = '';
            } else {
                $constraints = ' WHERE ' . implode(' AND ', $constraints);
            }

            if ($this->prefetch) {
                $this->initEntities($constraints, $this->makeJoins($joins), $this->makeOrderBy($sorting, $joins));
            } else {
                $this->initKeys($constraints, $this->makeJoins($joins), $this->makeOrderBy($sorting, $joins));
            }

            $this->rewind();
        }
    }