Init cache table. You must run this manually once.
557547
public  function createTable()
    {
        if ($this->cassandra instanceof Connection) {

            $cql = 'CREATE TABLE IF NOT EXISTS ' . $this->getTableFullName() . " (
                        key text PRIMARY KEY,
                        value blob
                    ) WITH COMPACT STORAGE AND
                    bloom_filter_fp_chance=0.001000 AND
                    caching='ALL' AND
                    comment='Used for cassandra caching at yii2' AND
                    dclocal_read_repair_chance=0.000000 AND
                    gc_grace_seconds=86400 AND
                    read_repair_chance=0.100000 AND
                    replicate_on_write='true' AND
                    populate_io_cache_on_flush='false' AND
                    compaction={'class': 'LeveledCompactionStrategy', 'sstable_size_in_mb': 256} AND
                    compression={'sstable_compression': 'DeflateCompressor'};";
            $this->cassandra->cql3Query($cql);
        }
    }
459042
function init(){
    if(!cacheServiceConfig) {
      cacheServiceConfig = {};
    }
    self.nameSpace = cacheServiceConfig.nameSpace || '';
    self.verbose = (typeof cacheServiceConfig.verbose === 'boolean') ? cacheServiceConfig.verbose : false;
    self.writeToVolatileCaches = (typeof cacheServiceConfig.writeToVolatileCaches === 'boolean') ? cacheServiceConfig.writeToVolatileCaches : true;
    self.caches = new CacheCollection({nameSpace: self.nameSpace, verbose: self.verbose}, cacheModules).caches;
    self.cachesLength = self.caches.length;
  }
1310771
public static void initialize()
    {
        if (InfinispanCache.get().exists(Group.IDCACHE)) {
            InfinispanCache.get().<Long, Group>getCache(Group.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Group>getCache(Group.IDCACHE).addListener(new CacheLogListener(Group.LOG));
        }
        if (InfinispanCache.get().exists(Group.NAMECACHE)) {
            InfinispanCache.get().<String, Group>getCache(Group.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Group>getCache(Group.NAMECACHE).addListener(new CacheLogListener(Group.LOG));
        }
        if (InfinispanCache.get().exists(Group.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Group>getCache(Group.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Group>getCache(Group.UUIDCACHE).addListener(new CacheLogListener(Group.LOG));
        }
    }
1076437
private function initialize()
    {
        $this->cacheDriver = $this->configuration->getMetadataCacheImpl();
        $this->driver = $this->configuration->getMetadataDriverImpl();

        if (null === $this->evm) {
            $this->evm = new EventManager();
        }
        
        $this->initialized = true;
    }
223148
public static void init(Context context, String name, int version, int cacheSize) {
		init(context, name, version, cacheSize, LogLevel.NONE);
	}
694902
private synchronized void startCache()
    {
        for (PDatabase pDatabase : m_htDBList.values())
        {
            for (PTable pTable : pDatabase.getTableList().values())
            {
                this.addTableToCache(pTable);
            }
        }
    }
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));
        }
    }
1269570
public function initialize(Table $table)
    {
        $this->table = $table;
        $this->table->isProcessing(true);
        $this->table->isServerSide(true);

        if (!is_null($this->ajax)) {
            $this->table->setAjax($this->ajax);
        }
    }
463580
public void init(boolean useDirect, int outSize, int inSize, int cacheSize) {
        super.init(useDirect, outSize, inSize, cacheSize);
    }
884981
def _run_init_queries(self):
        '''
        
        '''
        for obj in (Package, PackageCfgFile, PayloadFile, IgnoredDir, AllowedDir):
            self._db.create_table_from_object(obj())
282458
protected function initTable(): void
    {
        $tableClass = class_namespace(static::class) . '\\Table';

        // check class initialization
        if (!class_exists($tableClass) || !is_subclass_of($tableClass, TableInterface::class)) {
            throw new TableNotFoundException('`Table` class is not exists or not initialized');
        }

        /**
         * @var TableInterface $tableClass
         */
        $this->setTable($tableClass::getInstance());
    }
302474
private function initializeCache()
    {
        // get driver
        if (!($driver = $this->config->get('CompilerCacheDriver', false))) {
            // default driver
            if ($this->isDevelopment()) {
                $driver = self::DEV_CACHE_DRIVER;
            } else {
                $driver = self::PROD_CACHE_DRIVER;
            }
        }

        // create driver instance
        try {
            $instance = $this->factory($driver, CacheDriverInterface::class);
            $this->cacheInstance = new Cache($instance);
        } catch (Exception $e) {
            throw $e;
        }
    }
1269720
public static void initialize()
        throws CacheReloadException
    {
        Context.getDbType().initialize(AbstractDataModelObject.class);
        AttributeType.initialize(AbstractDataModelObject.class);
        SQLTable.initialize(AbstractDataModelObject.class);
        Type.initialize(AbstractDataModelObject.class);
        Dimension.initialize(AbstractDataModelObject.class);
        Attribute.initialize(AbstractDataModelObject.class);
        Status.initialize(AbstractDataModelObject.class);
    }
1110442
private synchronized static void initialize() {
    if(MASTER_CACHE != null) {
      return;
    }
    try {
      Enumeration<URL> cps = CLASSLOADER.getResources("");
      List<Class<?>> res = new ArrayList<>();
      while(cps.hasMoreElements()) {
        URL u = cps.nextElement();
        // Scan file sources only.
        if(!"file".equals(u.getProtocol())) {
          continue;
        }
        try {
          Iterator<String> it = new DirClassIterator(new File(u.toURI()));
          while(it.hasNext()) {
            try {
              Class<?> cls = CLASSLOADER.loadClass(it.next());
              // skip classes where we can't get a full name.
              if(cls.getCanonicalName() == null) {
                continue;
              }
              res.add(cls);
            }
            catch(Exception | Error e) {
              continue;
            }
          }
        }
        catch(URISyntaxException e) {
          LOG.warning("Incorrect classpath entry: " + u);
          continue;
        }
      }
      MASTER_CACHE = Collections.unmodifiableList(res);
      if(LOG.isDebuggingFinest()) {
        LOG.debugFinest("Classes found by scanning the development classpath: " + MASTER_CACHE.size());
      }
    }
    catch(IOException e) {
      LOG.exception(e);
      return;
    }
  }
406573
public static void initialize()
    {
        if (InfinispanCache.get().exists(Consortium.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Consortium>getCache(Consortium.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Consortium>getCache(Consortium.UUIDCACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
        if (InfinispanCache.get().exists(Consortium.IDCACHE)) {
            InfinispanCache.get().<Long, Consortium>getCache(Consortium.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Consortium>getCache(Consortium.IDCACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
        if (InfinispanCache.get().exists(Consortium.NAMECACHE)) {
            InfinispanCache.get().<String, Consortium>getCache(Consortium.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Consortium>getCache(Consortium.NAMECACHE)
                            .addListener(new CacheLogListener(Consortium.LOG));
        }
    }
52211
public function init() {

        parent::init();

        $this->autoload	= ( !empty( $this->autoloadUrl ) && CoreProperties::getInstance()->isAutoLoad() ) ? true : false;

		$this->cache = $this->cache ? $this->cache : CacheProperties::getInstance()->isCaching();
    }
528569
protected function init()
    {
        if ($this->policy != self::POLICY_NONE) {
            // cache role
            $this->role = $this->cache->load('role');
            if ($this->role === null) {
                $this->role = $this->connection->select('id, role')
                    ->from($this->tableRole)
                    ->fetchAssoc('role');

                $this->cache->save('role', $this->role, [Cache::TAGS => ['DibiDriver']]);  // cachovani bez expirace
            }

            // cache resource
            $this->resource = $this->cache->load('resource');
            if ($this->resource === null) {
                $this->resource = $this->connection->select('id, resource')
                    ->from($this->tableResource)
                    ->fetchAssoc('resource');

                $this->cache->save('resource', $this->resource, [Cache::TAGS => ['DibiDriver']]);  // cachovani bez expirace
            }

            // cache privilege
            $this->privilege = $this->cache->load('privilege');
            if ($this->privilege === null) {
                $this->privilege = $this->connection->select('id, privilege')
                    ->from($this->tablePrivilege)
                    ->fetchAssoc('privilege');

                $this->cache->save('privilege', $this->privilege, [Cache::TAGS => ['DibiDriver']]);  // cachovani bez expirace
            }

            // set permission role
            foreach ($this->role as $item) {
                $this->permission->addRole($item['role']);
            }

            // set permission resource
            foreach ($this->resource as $item) {
                if ($item['resource']) {
                    $this->permission->addResource($item['resource']);
                }
            }

            // for deny enable all
            if ($this->policy == self::POLICY_DENY) {
                $this->permission->allow();
            }

            // cache acl
            $this->acl = $this->cache->load('acl');
            if ($this->acl === null) {
                // strict define keys!
                $this->acl = $this->connection->select('acl.id,' .
                    'role.id id_role, role.role,' .
                    'resource.id id_resource, resource.resource,' .
                    'privilege.id id_privilege, privilege.privilege')
                    ->from($this->tableAcl)->as('acl')
                    ->join($this->tableRole)->as('role')->on('role.id=acl.id_role')
                    ->leftJoin($this->tableResource)->as('resource')->on('resource.id=acl.id_resource')
                    ->leftJoin($this->tablePrivilege)->as('privilege')->on('privilege.id=acl.id_privilege')
                    ->where(['acl.active' => true,])
                    ->orderBy(['acl.position' => 'asc'])
                    ->fetchAll();

                $this->cache->save('acl', $this->acl, [Cache::TAGS => ['DibiDriver']]);  // cachovani bez expirace
            }

            // set permission acl
            foreach ($this->acl as $item) {
                if ($item['role'] && $item['resource'] && $item['privilege']) {
                    $this->setAllowed($item['role'], $item['resource'], $item['privilege']);
                } else if ($item['role'] && $item['resource']) {
                    $this->setAllowed($item['role'], $item['resource']);
                } else if ($item['role']) {
                    $this->setAllowed($item['role']);
                }
            }
        }
    }