driver initialisation

@access	public
@return	void
344802
public function init()
	{
		// generic driver initialisation
		parent::init();

		if ($this->memcached === false)
		{
			// do we have the PHP memcached extension available
			if ( ! class_exists('Memcached') )
			{
				throw new \FuelException('Memcached sessions are configured, but your PHP installation doesn\'t have the Memcached extension loaded.');
			}

			// instantiate the memcached object
			$this->memcached = new \Memcached();

			// add the configured servers
			$this->memcached->addServers($this->config['servers']);

			// check if we can connect to the server(s)
			if ($this->memcached->getVersion() === false)
			{
				throw new \FuelException('Memcached sessions are configured, but there is no connection possible. Check your configuration.');
			}
		}
	}
48094
private function init(){
        //Load Archivos de Funciones
        $this->loadFunctionsFiles();
        //Instancio el sistema de Cache
        $this->cache= new Support\Cache\Cache();
        //EnolaContext->init(): Cargo las configuraciones de contexto faltante
        $this->context->init();
        //Instancio el motor de Dependencias
        $this->dependenciesEngine= new Support\DependencyEngine\DependenciesEngine();
        //Cargo las librerias definidas por el usuario
        $this->loadLibraries();
    }
577313
private function init()
    {
        $genericDevice = $this->getDevice(WURFL_Constants::GENERIC);
        if (!is_null($genericDevice)) {
            $this->_capabilitiesName = array_keys($genericDevice->getCapabilities());
            $this->_groupIDCapabilitiesMap = $genericDevice->getGroupIdCapabilitiesNameMap();
        }
    }
503123
private function buildDrivers()
    {
        $drivers = $this->getHasherConfig('drivers', []);

        foreach ($drivers as $name => $driver) {
            $this->buildDriver($name, $driver);
        }
    }
8852
protected function init()
    {
        $this->prepareHTTPManagers();
        $this->prepareHTTPRendersManager();
        $this->prepareMediotecasManager();

        $this->nb_engine->registerApplication($this);
    }
160467
public function init()
    {
        parent::init();
        $this->db = Instance::ensure($this->module->db, Connection::className());
        if ($this->db->driverName === 'mysql') {
            $this->tableOptions = 'CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE=InnoDB';
        }
    }
590971
public function init(): void
    {
        if ($this->initialized) {
            return;
        }
        if (!$this->view) {
            $containerGetter = 'get' . ucfirst($this->viewName);
            $this->setView(Container::$containerGetter());
        }
        if (method_exists($this, 'getAvailableHelpers')) {
            $this->registerHelpers($this->getAvailableHelpers());
        }
        
        $this->initialized = true;
    }
605599
protected function init()
    {
        global $wpdb;
        $this->wpdb = $wpdb;
        $this->queryGrammar = new MySqlGrammar();
        $this->postProcessor = new MySqlProcessor();
    }
355036
public function init()
    {
        if ($this->isEnabled()) {
            $this->client = \PHPDaemon\Clients\IRC\Pool::getInstance();
        }
    }
644482
public static function init()
    {

        // Initialize format drivers
        foreach (glob(implode(DIRECTORY_SEPARATOR, array(__DIR__,'Format','*.php'))) as $filename) {

            $filename = explode(DIRECTORY_SEPARATOR, $filename);
            $filename = explode('.',array_pop($filename));
            array_pop($filename);
            $filename = implode('.', $filename);

            if($filename == 'FormatInterface') continue;

            $className = explode("\\",__CLASS__);
            array_pop($className);
            array_push($className, 'Format');
            array_push($className, $filename);
            $className = implode('\\', $className);

            self::registerFormat($className);
        }

        // Initialize storage drivers
        foreach (glob(implode(DIRECTORY_SEPARATOR, array(__DIR__,'Storage','*.php'))) as $filename) {

            $filename = explode(DIRECTORY_SEPARATOR, $filename);
            $filename = explode('.',array_pop($filename));
            array_pop($filename);
            $filename = implode('.', $filename);

            if($filename == 'StorageInterface') continue;

            $className = explode("\\",__CLASS__);
            array_pop($className);
            array_push($className, 'Storage');
            array_push($className, $filename);
            $className = implode('\\', $className);

            self::registerStorage($className);
        }
    }
251761
public function initialize() {
        parent::initialize();

        $this->addClauses([
            self::UNION => 'UNION {flag} (%s)',
            self::USING => 'USING %s'
        ]);

        $this->addKeywords([
            self::AVG_ROW_LENGTH        => 'AVG_ROW_LENGTH',
            self::BIG_RESULT            => 'SQL_BIG_RESULT',
            self::BUFFER_RESULT         => 'SQL_BUFFER_RESULT',
            self::BTREE                 => 'BTREE',
            self::CACHE                 => 'SQL_CACHE',
            self::CONNECTION            => 'CONNECTION',
            self::DATA_DIRECTORY        => 'DATA DIRECTORY',
            self::DEFAULT_CHARACTER_SET => 'DEFAULT CHARACTER SET',
            self::DEFAULT_COMMENT       => 'DEFAULT COMMENT',
            self::DELAYED               => 'DELAYED',
            self::DELAY_KEY_WRITE       => 'DELAY_KEY_WRITE',
            self::DISTINCT_ROW          => 'DISTINCTROW',
            self::FOR_UPDATE_LOCK       => 'FOR UPDATE',
            self::FULLTEXT              => 'FULLTEXT',
            self::HASH                  => 'HASH',
            self::HIGH_PRIORITY         => 'HIGH_PRIORITY',
            self::INDEX_DIRECTORY       => 'INDEX DIRECTORY',
            self::INSERT_METHOD         => 'INSERT_METHOD',
            self::KEY_BLOCK_SIZE        => 'KEY_BLOCK_SIZE',
            self::LOW_PRIORITY          => 'LOW_PRIORITY',
            self::MAX_ROWS              => 'MAX_ROWS',
            self::MIN_ROWS              => 'MIN_ROWS',
            self::NO_CACHE              => 'SQL_NO_CACHE',
            self::PACK_KEYS             => 'PACK_KEYS',
            self::QUICK                 => 'QUICK',
            self::ROW_FORMAT            => 'ROW_FORMAT',
            self::SHARED_LOCK           => 'LOCK IN SHARE MODE',
            self::SMALL_RESULT          => 'SQL_SMALL_RESULT',
            self::SPATIAL               => 'SPATIAL',
            self::STATS_AUTO_RECALC     => 'STATS_AUTO_RECALC',
            self::STATS_PERSISTENT      => 'STATS_PERSISTENT',
            self::UNIQUE                => 'UNIQUE'
        ]);

        $this->addStatements([
            Query::INSERT        => new Statement('INSERT {priority} {ignore} INTO {table} {fields} VALUES {values}'),
            Query::SELECT        => new Statement('SELECT {distinct} {priority} {optimize} {cache} {fields} FROM {table} {joins} {where} {groupBy} {having} {compounds} {orderBy} {limit} {lock}'),
            Query::UPDATE        => new Statement('UPDATE {priority} {ignore} {table} {joins} SET {fields} {where} {orderBy} {limit}'),
            Query::DELETE        => new Statement('DELETE {priority} {quick} {ignore} FROM {table} {joins} {where} {orderBy} {limit}'),
            Query::TRUNCATE      => new Statement('TRUNCATE {table}'),
            Query::CREATE_TABLE  => new Statement("CREATE {temporary} TABLE IF NOT EXISTS {table} (\n{columns}{keys}\n) {options}"),
            Query::CREATE_INDEX  => new Statement('CREATE {type} INDEX {index} ON {table} ({fields}) {using}'),
            Query::DROP_TABLE    => new Statement('DROP {temporary} TABLE IF EXISTS {table}'),
            Query::DROP_INDEX    => new Statement('DROP INDEX {index} ON {table}')
        ]);
    }
1288984
protected function attachDrivers()
    {
        $drivers = $this->getDrivers();
        foreach ($drivers as $driver) {
            $handler = $this->getHandlerInstanceByName($driver);
            $this->attachHandler($handler);
        }
    }
545108
protected function init()
    {
        $method = $this->options['persistent'] ? 'pconnect' : 'connect';

        try {
            if (strpos($this->options['host'], '/') === 0) {
                $this->redis->{$method}($this->options['host']);
            } else {
                $this->redis->{$method}($this->options['host'], $this->options['port']);
            }

            if ($this->options['auth']) {
                $this->redis->auth($this->options['auth']);
            }
        } catch (\Exception $e) {
            throw new PhealException('Connecting to cache failed!', null, $e);
        }
    }
1183151
protected function init()
    {
        $this->registers = [
            static::PHP_SHELL => PhpShellRegisterProvider::class,
        ];
        $this->validators = [
            static::PHP_SHELL => PhpShellValidatorProvider::class,
        ];
        $this->conditions = [
            static::PHP_SHELL => PhpShellConditionProvider::class
        ];
        $this->functions = [
            static::PHP_SHELL => PhpShellFunctionProvider::class
        ];
    }
332433
public function initialise()
    {
        $this->lti_context_id = null;
        $this->lti_resource_id = null;
        $this->title = '';
        $this->settings = [];
        $this->groupSets = null;
        $this->groups = null;
        $this->primary_consumer_key = null;
        $this->primary_resource_link_id = null;
        $this->share_approved = null;
        $this->created = null;
        $this->updated = null;
    }
794349
def init_drivers(enable_debug_driver=False):
    """"""
    for driver in DRIVERS:
        try:
            if driver != DebugDriver or enable_debug_driver:
                CLASSES.append(driver)
        except Exception:  # pylint: disable=W0703
            continue
122739
protected function init()
    {
        $this->client = new Client(
            $this->getOption('user_id'),
            $this->getOption('license_key'),
            $this->getOption('locales', ['en'])
        );
    }